(function (global, factory) {
  typeof exports === "object" && typeof module !== "undefined"
    ? (module.exports = factory())
    : typeof define === "function" && define.amd
    ? define(factory)
    : ((global = global || self), (global.dstpSecurityPage = factory()));
})(this, function () {
  "use strict";

  function createCommonjsModule(fn, basedir, module) {
    return (
      (module = {
        path: basedir,
        exports: {},
        require: function (path, base) {
          return commonjsRequire(
            path,
            base === undefined || base === null ? module.path : base
          );
        },
      }),
      fn(module, module.exports),
      module.exports
    );
  }

  function commonjsRequire() {
    throw new Error(
      "Dynamic requires are not currently supported by @rollup/plugin-commonjs"
    );
  }

  var _global = createCommonjsModule(function (module) {
    var global = (module.exports =
      typeof window != "undefined" && window.Math == Math
        ? window
        : typeof self != "undefined" && self.Math == Math
        ? self // eslint-disable-next-line no-new-func
        : Function("return this")());
    if (typeof __g == "number") __g = global; // eslint-disable-line no-undef
  });

  var _core = createCommonjsModule(function (module) {
    var core = (module.exports = {
      version: "2.6.12",
    });
    if (typeof __e == "number") __e = core; // eslint-disable-line no-undef
  });

  var _isObject = function (it) {
    return typeof it === "object" ? it !== null : typeof it === "function";
  };

  var _anObject = function (it) {
    if (!_isObject(it)) throw TypeError(it + " is not an object!");
    return it;
  };

  var _fails = function (exec) {
    try {
      return !!exec();
    } catch (e) {
      return true;
    }
  };

  var _descriptors = !_fails(function () {
    return (
      Object.defineProperty({}, "a", {
        get: function () {
          return 7;
        },
      }).a != 7
    );
  });

  var document$1 = _global.document; // typeof document.createElement is 'object' in old IE

  var is = _isObject(document$1) && _isObject(document$1.createElement);

  var _domCreate = function (it) {
    return is ? document$1.createElement(it) : {};
  };

  var _ie8DomDefine =
    !_descriptors &&
    !_fails(function () {
      return (
        Object.defineProperty(_domCreate("div"), "a", {
          get: function () {
            return 7;
          },
        }).a != 7
      );
    });

  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string

  var _toPrimitive = function (it, S) {
    if (!_isObject(it)) return it;
    var fn, val;
    if (
      S &&
      typeof (fn = it.toString) == "function" &&
      !_isObject((val = fn.call(it)))
    )
      return val;
    if (
      typeof (fn = it.valueOf) == "function" &&
      !_isObject((val = fn.call(it)))
    )
      return val;
    if (
      !S &&
      typeof (fn = it.toString) == "function" &&
      !_isObject((val = fn.call(it)))
    )
      return val;
    throw TypeError("Can't convert object to primitive value");
  };

  var dP = Object.defineProperty;
  var f = _descriptors
    ? Object.defineProperty
    : function defineProperty(O, P, Attributes) {
        _anObject(O);
        P = _toPrimitive(P, true);
        _anObject(Attributes);
        if (_ie8DomDefine)
          try {
            return dP(O, P, Attributes);
          } catch (e) {
            /* empty */
          }
        if ("get" in Attributes || "set" in Attributes)
          throw TypeError("Accessors not supported!");
        if ("value" in Attributes) O[P] = Attributes.value;
        return O;
      };
  var _objectDp = {
    f: f,
  };

  var _propertyDesc = function (bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value,
    };
  };

  var _hide = _descriptors
    ? function (object, key, value) {
        return _objectDp.f(object, key, _propertyDesc(1, value));
      }
    : function (object, key, value) {
        object[key] = value;
        return object;
      };

  var hasOwnProperty = {}.hasOwnProperty;

  var _has = function (it, key) {
    return hasOwnProperty.call(it, key);
  };

  var id = 0;
  var px = Math.random();

  var _uid = function (key) {
    return "Symbol(".concat(
      key === undefined ? "" : key,
      ")_",
      (++id + px).toString(36)
    );
  };

  var _library = false;

  var _shared = createCommonjsModule(function (module) {
    var SHARED = "__core-js_shared__";
    var store = _global[SHARED] || (_global[SHARED] = {});
    (module.exports = function (key, value) {
      return store[key] || (store[key] = value !== undefined ? value : {});
    })("versions", []).push({
      version: _core.version,
      mode: "global",
      copyright: "© 2020 Denis Pushkarev (zloirock.ru)",
    });
  });

  var _functionToString = _shared(
    "native-function-to-string",
    Function.toString
  );

  var _redefine = createCommonjsModule(function (module) {
    var SRC = _uid("src");
    var TO_STRING = "toString";
    var TPL = ("" + _functionToString).split(TO_STRING);

    _core.inspectSource = function (it) {
      return _functionToString.call(it);
    };

    (module.exports = function (O, key, val, safe) {
      var isFunction = typeof val == "function";
      if (isFunction) _has(val, "name") || _hide(val, "name", key);
      if (O[key] === val) return;
      if (isFunction)
        _has(val, SRC) ||
          _hide(val, SRC, O[key] ? "" + O[key] : TPL.join(String(key)));

      if (O === _global) {
        O[key] = val;
      } else if (!safe) {
        delete O[key];
        _hide(O, key, val);
      } else if (O[key]) {
        O[key] = val;
      } else {
        _hide(O, key, val);
      } // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
    })(Function.prototype, TO_STRING, function toString() {
      return (
        (typeof this == "function" && this[SRC]) || _functionToString.call(this)
      );
    });
  });

  var _aFunction = function (it) {
    if (typeof it != "function") throw TypeError(it + " is not a function!");
    return it;
  };

  var _ctx = function (fn, that, length) {
    _aFunction(fn);
    if (that === undefined) return fn;

    switch (length) {
      case 1:
        return function (a) {
          return fn.call(that, a);
        };

      case 2:
        return function (a, b) {
          return fn.call(that, a, b);
        };

      case 3:
        return function (a, b, c) {
          return fn.call(that, a, b, c);
        };
    }

    return function () /* ...args */
    {
      return fn.apply(that, arguments);
    };
  };

  var PROTOTYPE = "prototype";

  var $export = function (type, name, source) {
    var IS_FORCED = type & $export.F;
    var IS_GLOBAL = type & $export.G;
    var IS_STATIC = type & $export.S;
    var IS_PROTO = type & $export.P;
    var IS_BIND = type & $export.B;
    var target = IS_GLOBAL
      ? _global
      : IS_STATIC
      ? _global[name] || (_global[name] = {})
      : (_global[name] || {})[PROTOTYPE];
    var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});
    var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
    var key, own, out, exp;
    if (IS_GLOBAL) source = name;

    for (key in source) {
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined; // export native or passed

      out = (own ? target : source)[key]; // bind timers to global for call from export context

      exp =
        IS_BIND && own
          ? _ctx(out, _global)
          : IS_PROTO && typeof out == "function"
          ? _ctx(Function.call, out)
          : out; // extend global

      if (target) _redefine(target, key, out, type & $export.U); // export

      if (exports[key] != out) _hide(exports, key, exp);
      if (IS_PROTO && expProto[key] != out) expProto[key] = out;
    }
  };

  _global.core = _core; // type bitmap

  $export.F = 1; // forced

  $export.G = 2; // global

  $export.S = 4; // static

  $export.P = 8; // proto

  $export.B = 16; // bind

  $export.W = 32; // wrap

  $export.U = 64; // safe

  $export.R = 128; // real proto method for `library`

  var _export = $export;

  var toString = {}.toString;

  var _cof = function (it) {
    return toString.call(it).slice(8, -1);
  };

  // eslint-disable-next-line no-prototype-builtins

  var _iobject = Object("z").propertyIsEnumerable(0)
    ? Object
    : function (it) {
        return _cof(it) == "String" ? it.split("") : Object(it);
      };

  // 7.2.1 RequireObjectCoercible(argument)
  var _defined = function (it) {
    if (it == undefined) throw TypeError("Can't call method on  " + it);
    return it;
  };

  var _toIobject = function (it) {
    return _iobject(_defined(it));
  };

  // 7.1.4 ToInteger
  var ceil = Math.ceil;
  var floor = Math.floor;

  var _toInteger = function (it) {
    return isNaN((it = +it)) ? 0 : (it > 0 ? floor : ceil)(it);
  };

  var min = Math.min;

  var _toLength = function (it) {
    return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  };

  var max = Math.max;
  var min$1 = Math.min;

  var _toAbsoluteIndex = function (index, length) {
    index = _toInteger(index);
    return index < 0 ? max(index + length, 0) : min$1(index, length);
  };

  // true  -> Array#includes

  var _arrayIncludes = function (IS_INCLUDES) {
    return function ($this, el, fromIndex) {
      var O = _toIobject($this);
      var length = _toLength(O.length);
      var index = _toAbsoluteIndex(fromIndex, length);
      var value; // Array#includes uses SameValueZero equality algorithm
      // eslint-disable-next-line no-self-compare

      if (IS_INCLUDES && el != el)
        while (length > index) {
          value = O[index++]; // eslint-disable-next-line no-self-compare

          if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not
        }
      else
        for (; length > index; index++)
          if (IS_INCLUDES || index in O) {
            if (O[index] === el) return IS_INCLUDES || index || 0;
          }
      return !IS_INCLUDES && -1;
    };
  };

  var shared = _shared("keys");

  var _sharedKey = function (key) {
    return shared[key] || (shared[key] = _uid(key));
  };

  var arrayIndexOf = _arrayIncludes(false);
  var IE_PROTO = _sharedKey("IE_PROTO");

  var _objectKeysInternal = function (object, names) {
    var O = _toIobject(object);
    var i = 0;
    var result = [];
    var key;

    for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key); // Don't enum bug & hidden keys

    while (names.length > i)
      if (_has(O, (key = names[i++]))) {
        ~arrayIndexOf(result, key) || result.push(key);
      }

    return result;
  };

  // IE 8- don't enum bug keys
  var _enumBugKeys =
    "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(
      ","
    );

  var _objectKeys =
    Object.keys ||
    function keys(O) {
      return _objectKeysInternal(O, _enumBugKeys);
    };

  var f$1 = Object.getOwnPropertySymbols;
  var _objectGops = {
    f: f$1,
  };

  var f$2 = {}.propertyIsEnumerable;
  var _objectPie = {
    f: f$2,
  };

  var _toObject = function (it) {
    return Object(_defined(it));
  };

  var $assign = Object.assign; // should work with symbols and should have deterministic property order (V8 bug)

  var _objectAssign =
    !$assign ||
    _fails(function () {
      var A = {};
      var B = {}; // eslint-disable-next-line no-undef

      var S = Symbol();
      var K = "abcdefghijklmnopqrst";
      A[S] = 7;
      K.split("").forEach(function (k) {
        B[k] = k;
      });
      return (
        $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join("") != K
      );
    })
      ? function assign(target, source) {
          // eslint-disable-line no-unused-vars
          var T = _toObject(target);
          var aLen = arguments.length;
          var index = 1;
          var getSymbols = _objectGops.f;
          var isEnum = _objectPie.f;

          while (aLen > index) {
            var S = _iobject(arguments[index++]);
            var keys = getSymbols
              ? _objectKeys(S).concat(getSymbols(S))
              : _objectKeys(S);
            var length = keys.length;
            var j = 0;
            var key;

            while (length > j) {
              key = keys[j++];
              if (!_descriptors || isEnum.call(S, key)) T[key] = S[key];
            }
          }

          return T;
        }
      : $assign;

  _export(_export.S + _export.F, "Object", {
    assign: _objectAssign,
  });

  function _typeof(obj) {
    "@babel/helpers - typeof";

    return (
      (_typeof =
        "function" == typeof Symbol && "symbol" == typeof Symbol.iterator
          ? function (obj) {
              return typeof obj;
            }
          : function (obj) {
              return obj &&
                "function" == typeof Symbol &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            }),
      _typeof(obj)
    );
  }

  _export(_export.S + _export.F * !_descriptors, "Object", {
    defineProperty: _objectDp.f,
  });

  var _wks = createCommonjsModule(function (module) {
    var store = _shared("wks");
    var Symbol = _global.Symbol;
    var USE_SYMBOL = typeof Symbol == "function";

    var $exports = (module.exports = function (name) {
      return (
        store[name] ||
        (store[name] =
          (USE_SYMBOL && Symbol[name]) ||
          (USE_SYMBOL ? Symbol : _uid)("Symbol." + name))
      );
    });

    $exports.store = store;
  });

  var TAG = _wks("toStringTag"); // ES3 wrong here

  var ARG =
    _cof(
      (function () {
        return arguments;
      })()
    ) == "Arguments"; // fallback for IE11 Script Access Denied error

  var tryGet = function (it, key) {
    try {
      return it[key];
    } catch (e) {
      /* empty */
    }
  };

  var _classof = function (it) {
    var O, T, B;
    return it === undefined
      ? "Undefined"
      : it === null
      ? "Null" // @@toStringTag case
      : typeof (T = tryGet((O = Object(it)), TAG)) == "string"
      ? T // builtinTag case
      : ARG
      ? _cof(O) // ES3 arguments fallback
      : (B = _cof(O)) == "Object" && typeof O.callee == "function"
      ? "Arguments"
      : B;
  };

  var test = {};
  test[_wks("toStringTag")] = "z";

  if (test + "" != "[object z]") {
    _redefine(
      Object.prototype,
      "toString",
      function toString() {
        return "[object " + _classof(this) + "]";
      },
      true
    );
  }

  var DateProto = Date.prototype;
  var INVALID_DATE = "Invalid Date";
  var TO_STRING = "toString";
  var $toString = DateProto[TO_STRING];
  var getTime = DateProto.getTime;

  if (new Date(NaN) + "" != INVALID_DATE) {
    _redefine(DateProto, TO_STRING, function toString() {
      var value = getTime.call(this); // eslint-disable-next-line no-self-compare

      return value === value ? $toString.call(this) : INVALID_DATE;
    });
  }

  var _flags = function () {
    var that = _anObject(this);
    var result = "";
    if (that.global) result += "g";
    if (that.ignoreCase) result += "i";
    if (that.multiline) result += "m";
    if (that.unicode) result += "u";
    if (that.sticky) result += "y";
    return result;
  };

  if (_descriptors && /./g.flags != "g")
    _objectDp.f(RegExp.prototype, "flags", {
      configurable: true,
      get: _flags,
    });

  var TO_STRING$1 = "toString";
  var $toString$1 = /./[TO_STRING$1];

  var define = function (fn) {
    _redefine(RegExp.prototype, TO_STRING$1, fn, true);
  }; // RegExp.prototype.toString()

  if (
    _fails(function () {
      return (
        $toString$1.call({
          source: "a",
          flags: "b",
        }) != "/a/b"
      );
    })
  ) {
    define(function toString() {
      var R = _anObject(this);
      return "/".concat(
        R.source,
        "/",
        "flags" in R
          ? R.flags
          : !_descriptors && R instanceof RegExp
          ? _flags.call(R)
          : undefined
      );
    }); // FF44- RegExp#toString has a wrong name
  } else if ($toString$1.name != TO_STRING$1) {
    define(function toString() {
      return $toString$1.call(this);
    });
  }

  var MATCH = _wks("match");

  var _isRegexp = function (it) {
    var isRegExp;
    return (
      _isObject(it) &&
      ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : _cof(it) == "RegExp")
    );
  };

  var SPECIES = _wks("species");

  var _speciesConstructor = function (O, D) {
    var C = _anObject(O).constructor;
    var S;
    return C === undefined || (S = _anObject(C)[SPECIES]) == undefined
      ? D
      : _aFunction(S);
  };

  // false -> String#codePointAt

  var _stringAt = function (TO_STRING) {
    return function (that, pos) {
      var s = String(_defined(that));
      var i = _toInteger(pos);
      var l = s.length;
      var a, b;
      if (i < 0 || i >= l) return TO_STRING ? "" : undefined;
      a = s.charCodeAt(i);
      return a < 0xd800 ||
        a > 0xdbff ||
        i + 1 === l ||
        (b = s.charCodeAt(i + 1)) < 0xdc00 ||
        b > 0xdfff
        ? TO_STRING
          ? s.charAt(i)
          : a
        : TO_STRING
        ? s.slice(i, i + 2)
        : ((a - 0xd800) << 10) + (b - 0xdc00) + 0x10000;
    };
  };

  var at = _stringAt(true); // `AdvanceStringIndex` abstract operation


  var _advanceStringIndex = function (S, index, unicode) {
    return index + (unicode ? at(S, index).length : 1);
  };

  var builtinExec = RegExp.prototype.exec; // `RegExpExec` abstract operation


  var _regexpExecAbstract = function (R, S) {
    var exec = R.exec;

    if (typeof exec === "function") {
      var result = exec.call(R, S);

      if (typeof result !== "object") {
        throw new TypeError(
          "RegExp exec method returned something other than an Object or null"
        );
      }

      return result;
    }

    if (_classof(R) !== "RegExp") {
      throw new TypeError("RegExp#exec called on incompatible receiver");
    }

    return builtinExec.call(R, S);
  };

  var nativeExec = RegExp.prototype.exec; // This always refers to the native implementation, because the
  // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
  // which loads this file before patching the method.

  var nativeReplace = String.prototype.replace;
  var patchedExec = nativeExec;
  var LAST_INDEX = "lastIndex";

  var UPDATES_LAST_INDEX_WRONG = (function () {
    var re1 = /a/,
      re2 = /b*/g;
    nativeExec.call(re1, "a");
    nativeExec.call(re2, "a");
    return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0;
  })(); // nonparticipating capturing group, copied from es5-shim's String#split patch.

  var NPCG_INCLUDED = /()??/.exec("")[1] !== undefined;
  var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;

  if (PATCH) {
    patchedExec = function exec(str) {
      var re = this;
      var lastIndex, reCopy, match, i;

      if (NPCG_INCLUDED) {
        reCopy = new RegExp("^" + re.source + "$(?!\\s)", _flags.call(re));
      }

      if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX];
      match = nativeExec.call(re, str);

      if (UPDATES_LAST_INDEX_WRONG && match) {
        re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex;
      }

      if (NPCG_INCLUDED && match && match.length > 1) {
        // Fix browsers whose `exec` methods don't consistently return `undefined`
        // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
        // eslint-disable-next-line no-loop-func
        nativeReplace.call(match[0], reCopy, function () {
          for (i = 1; i < arguments.length - 2; i++) {
            if (arguments[i] === undefined) match[i] = undefined;
          }
        });
      }

      return match;
    };
  }

  var _regexpExec = patchedExec;

  _export(
    {
      target: "RegExp",
      proto: true,
      forced: _regexpExec !== /./.exec,
    },
    {
      exec: _regexpExec,
    }
  );

  var SPECIES$1 = _wks("species");
  var REPLACE_SUPPORTS_NAMED_GROUPS = !_fails(function () {
    // #replace needs built-in support for named groups.
    // #match works fine because it just return the exec results, even if it has
    // a "grops" property.
    var re = /./;

    re.exec = function () {
      var result = [];
      result.groups = {
        a: "7",
      };
      return result;
    };

    return "".replace(re, "$<a>") !== "7";
  });

  var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {
    // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
    var re = /(?:)/;
    var originalExec = re.exec;

    re.exec = function () {
      return originalExec.apply(this, arguments);
    };

    var result = "ab".split(re);
    return result.length === 2 && result[0] === "a" && result[1] === "b";
  })();

  var _fixReWks = function (KEY, length, exec) {
    var SYMBOL = _wks(KEY);
    var DELEGATES_TO_SYMBOL = !_fails(function () {
      // String methods call symbol-named RegEp methods
      var O = {};

      O[SYMBOL] = function () {
        return 7;
      };

      return ""[KEY](O) != 7;
    });
    var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL
      ? !_fails(function () {
          // Symbol-named RegExp methods call .exec
          var execCalled = false;
          var re = /a/;

          re.exec = function () {
            execCalled = true;
            return null;
          };

          if (KEY === "split") {
            // RegExp[@@split] doesn't call the regex's exec method, but first creates
            // a new one. We need to return the patched regex when creating the new one.
            re.constructor = {};

            re.constructor[SPECIES$1] = function () {
              return re;
            };
          }

          re[SYMBOL]("");
          return !execCalled;
        })
      : undefined;

    if (
      !DELEGATES_TO_SYMBOL ||
      !DELEGATES_TO_EXEC ||
      (KEY === "replace" && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
      (KEY === "split" && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
    ) {
      var nativeRegExpMethod = /./[SYMBOL];
      var fns = exec(
        _defined,
        SYMBOL,
        ""[KEY],
        function maybeCallNative(
          nativeMethod,
          regexp,
          str,
          arg2,
          forceStringMethod
        ) {
          if (regexp.exec === _regexpExec) {
            if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
              // The native String method already delegates to @@method (this
              // polyfilled function), leasing to infinite recursion.
              // We avoid it by directly calling the native @@method method.
              return {
                done: true,
                value: nativeRegExpMethod.call(regexp, str, arg2),
              };
            }

            return {
              done: true,
              value: nativeMethod.call(str, regexp, arg2),
            };
          }

          return {
            done: false,
          };
        }
      );
      var strfn = fns[0];
      var rxfn = fns[1];
      _redefine(String.prototype, KEY, strfn);
      _hide(
        RegExp.prototype,
        SYMBOL,
        length == 2 // RegExp.prototype[@@replace](string, replaceValue)
          ? // RegExp.prototype[@@split](string, limit)
            function (string, arg) {
              return rxfn.call(string, this, arg);
            } //  RegExp.prototype[@@match](string)
          : // RegExp.prototype[@@search](string)
            function (string) {
              return rxfn.call(string, this);
            }
      );
    }
  };

  var $min = Math.min;
  var $push = [].push;
  var $SPLIT = "split";
  var LENGTH = "length";
  var LAST_INDEX$1 = "lastIndex";
  var MAX_UINT32 = 0xffffffff; // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError

  var SUPPORTS_Y = !_fails(function () {
    RegExp(MAX_UINT32, "y");
  }); // @@split logic

  _fixReWks("split", 2, function (defined, SPLIT, $split, maybeCallNative) {
    var internalSplit;

    if (
      "abbc"[$SPLIT](/(b)*/)[1] == "c" ||
      "test"[$SPLIT](/(?:)/, -1)[LENGTH] != 4 ||
      "ab"[$SPLIT](/(?:ab)*/)[LENGTH] != 2 ||
      "."[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 ||
      "."[$SPLIT](/()()/)[LENGTH] > 1 ||
      ""[$SPLIT](/.?/)[LENGTH]
    ) {
      // based on es5-shim implementation, need to rework it
      internalSplit = function (separator, limit) {
        var string = String(this);
        if (separator === undefined && limit === 0) return []; // If `separator` is not a regex, use native split

        if (!_isRegexp(separator)) return $split.call(string, separator, limit);
        var output = [];
        var flags =
          (separator.ignoreCase ? "i" : "") +
          (separator.multiline ? "m" : "") +
          (separator.unicode ? "u" : "") +
          (separator.sticky ? "y" : "");
        var lastLastIndex = 0;
        var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0; // Make `global` and avoid `lastIndex` issues by working with a copy

        var separatorCopy = new RegExp(separator.source, flags + "g");
        var match, lastIndex, lastLength;

        while ((match = _regexpExec.call(separatorCopy, string))) {
          lastIndex = separatorCopy[LAST_INDEX$1];

          if (lastIndex > lastLastIndex) {
            output.push(string.slice(lastLastIndex, match.index));
            if (match[LENGTH] > 1 && match.index < string[LENGTH])
              $push.apply(output, match.slice(1));
            lastLength = match[0][LENGTH];
            lastLastIndex = lastIndex;
            if (output[LENGTH] >= splitLimit) break;
          }

          if (separatorCopy[LAST_INDEX$1] === match.index)
            separatorCopy[LAST_INDEX$1]++; // Avoid an infinite loop
        }

        if (lastLastIndex === string[LENGTH]) {
          if (lastLength || !separatorCopy.test("")) output.push("");
        } else output.push(string.slice(lastLastIndex));

        return output[LENGTH] > splitLimit
          ? output.slice(0, splitLimit)
          : output;
      }; // Chakra, V8
    } else if ("0"[$SPLIT](undefined, 0)[LENGTH]) {
      internalSplit = function (separator, limit) {
        return separator === undefined && limit === 0
          ? []
          : $split.call(this, separator, limit);
      };
    } else {
      internalSplit = $split;
    }

    return [
      // `String.prototype.split` method

      function split(separator, limit) {
        var O = defined(this);
        var splitter = separator == undefined ? undefined : separator[SPLIT];
        return splitter !== undefined
          ? splitter.call(separator, O, limit)
          : internalSplit.call(String(O), separator, limit);
      }, // `RegExp.prototype[@@split]` method

      //
      // NOTE: This cannot be properly polyfilled in engines that don't support
      // the 'y' flag.
      function (regexp, limit) {
        var res = maybeCallNative(
          internalSplit,
          regexp,
          this,
          limit,
          internalSplit !== $split
        );
        if (res.done) return res.value;
        var rx = _anObject(regexp);
        var S = String(this);
        var C = _speciesConstructor(rx, RegExp);
        var unicodeMatching = rx.unicode;
        var flags =
          (rx.ignoreCase ? "i" : "") +
          (rx.multiline ? "m" : "") +
          (rx.unicode ? "u" : "") +
          (SUPPORTS_Y ? "y" : "g"); // ^(? + rx + ) is needed, in combination with some S slicing, to
        // simulate the 'y' flag.

        var splitter = new C(SUPPORTS_Y ? rx : "^(?:" + rx.source + ")", flags);
        var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
        if (lim === 0) return [];
        if (S.length === 0)
          return _regexpExecAbstract(splitter, S) === null ? [S] : [];
        var p = 0;
        var q = 0;
        var A = [];

        while (q < S.length) {
          splitter.lastIndex = SUPPORTS_Y ? q : 0;
          var z = _regexpExecAbstract(splitter, SUPPORTS_Y ? S : S.slice(q));
          var e;

          if (
            z === null ||
            (e = $min(
              _toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)),
              S.length
            )) === p
          ) {
            q = _advanceStringIndex(S, q, unicodeMatching);
          } else {
            A.push(S.slice(p, q));
            if (A.length === lim) return A;

            for (var i = 1; i <= z.length - 1; i++) {
              A.push(z[i]);
              if (A.length === lim) return A;
            }

            q = p = e;
          }
        }

        A.push(S.slice(p));
        return A;
      },
    ];
  });

  var _objectSap = function (KEY, exec) {
    var fn = (_core.Object || {})[KEY] || Object[KEY];
    var exp = {};
    exp[KEY] = exec(fn);
    _export(
      _export.S +
        _export.F *
          _fails(function () {
            fn(1);
          }),
      "Object",
      exp
    );
  };

  _objectSap("isExtensible", function ($isExtensible) {
    return function isExtensible(it) {
      return _isObject(it) ? ($isExtensible ? $isExtensible(it) : true) : false;
    };
  });

  var _meta = createCommonjsModule(function (module) {
    var META = _uid("meta");
    var setDesc = _objectDp.f;
    var id = 0;

    var isExtensible =
      Object.isExtensible ||
      function () {
        return true;
      };

    var FREEZE = !_fails(function () {
      return isExtensible(Object.preventExtensions({}));
    });

    var setMeta = function (it) {
      setDesc(it, META, {
        value: {
          i: "O" + ++id,
          // object ID
          w: {}, // weak collections IDs
        },
      });
    };

    var fastKey = function (it, create) {
      // return primitive with prefix
      if (!_isObject(it))
        return typeof it == "symbol"
          ? it
          : (typeof it == "string" ? "S" : "P") + it;

      if (!_has(it, META)) {
        // can't set metadata to uncaught frozen object
        if (!isExtensible(it)) return "F"; // not necessary to add metadata

        if (!create) return "E"; // add missing metadata

        setMeta(it); // return object ID
      }

      return it[META].i;
    };

    var getWeak = function (it, create) {
      if (!_has(it, META)) {
        // can't set metadata to uncaught frozen object
        if (!isExtensible(it)) return true; // not necessary to add metadata

        if (!create) return false; // add missing metadata

        setMeta(it); // return hash weak collections IDs
      }

      return it[META].w;
    }; // add metadata on freeze-family methods calling

    var onFreeze = function (it) {
      if (FREEZE && meta.NEED && isExtensible(it) && !_has(it, META))
        setMeta(it);
      return it;
    };

    var meta = (module.exports = {
      KEY: META,
      NEED: false,
      fastKey: fastKey,
      getWeak: getWeak,
      onFreeze: onFreeze,
    });
  });

  var meta = _meta.onFreeze;
  _objectSap("preventExtensions", function ($preventExtensions) {
    return function preventExtensions(it) {
      return $preventExtensions && _isObject(it)
        ? $preventExtensions(meta(it))
        : it;
    };
  });

  var document$2 = _global.document;

  var _html = document$2 && document$2.documentElement;

  var arraySlice = [].slice; // fallback for not array-like ES3 strings and DOM objects

  _export(
    _export.P +
      _export.F *
        _fails(function () {
          if (_html) arraySlice.call(_html);
        }),
    "Array",
    {
      slice: function slice(begin, end) {
        var len = _toLength(this.length);
        var klass = _cof(this);
        end = end === undefined ? len : end;
        if (klass == "Array") return arraySlice.call(this, begin, end);
        var start = _toAbsoluteIndex(begin, len);
        var upTo = _toAbsoluteIndex(end, len);
        var size = _toLength(upTo - start);
        var cloned = new Array(size);
        var i = 0;

        for (; i < size; i++)
          cloned[i] =
            klass == "String" ? this.charAt(start + i) : this[start + i];

        return cloned;
      },
    }
  );

  _objectSap("keys", function () {
    return function keys(it) {
      return _objectKeys(_toObject(it));
    };
  });

  var def = _objectDp.f;
  var TAG$1 = _wks("toStringTag");

  var _setToStringTag = function (it, tag, stat) {
    if (it && !_has((it = stat ? it : it.prototype), TAG$1))
      def(it, TAG$1, {
        configurable: true,
        value: tag,
      });
  };

  var f$3 = _wks;
  var _wksExt = {
    f: f$3,
  };

  var defineProperty = _objectDp.f;

  var _wksDefine = function (name) {
    var $Symbol = _core.Symbol || (_core.Symbol = _global.Symbol || {});
    if (name.charAt(0) != "_" && !(name in $Symbol))
      defineProperty($Symbol, name, {
        value: _wksExt.f(name),
      });
  };

  var _enumKeys = function (it) {
    var result = _objectKeys(it);
    var getSymbols = _objectGops.f;

    if (getSymbols) {
      var symbols = getSymbols(it);
      var isEnum = _objectPie.f;
      var i = 0;
      var key;

      while (symbols.length > i)
        if (isEnum.call(it, (key = symbols[i++]))) result.push(key);
    }

    return result;
  };

  var _isArray =
    Array.isArray ||
    function isArray(arg) {
      return _cof(arg) == "Array";
    };

  var _objectDps = _descriptors
    ? Object.defineProperties
    : function defineProperties(O, Properties) {
        _anObject(O);
        var keys = _objectKeys(Properties);
        var length = keys.length;
        var i = 0;
        var P;

        while (length > i) _objectDp.f(O, (P = keys[i++]), Properties[P]);

        return O;
      };

  var IE_PROTO$1 = _sharedKey("IE_PROTO");

  var Empty = function () {
    /* empty */
  };

  var PROTOTYPE$1 = "prototype"; // Create object with fake `null` prototype: use iframe Object with cleared prototype

  var createDict = function () {
    // Thrash, waste and sodomy: IE GC bug
    var iframe = _domCreate("iframe");
    var i = _enumBugKeys.length;
    var lt = "<";
    var gt = ">";
    var iframeDocument;
    iframe.style.display = "none";
    _html.appendChild(iframe);
    iframe.src = "javascript:"; // eslint-disable-line no-script-url
    // createDict = iframe.contentWindow.Object;
    // html.removeChild(iframe);

    iframeDocument = iframe.contentWindow.document;
    iframeDocument.open();
    iframeDocument.write(
      lt + "script" + gt + "document.F=Object" + lt + "/script" + gt
    );
    iframeDocument.close();
    createDict = iframeDocument.F;

    while (i--) delete createDict[PROTOTYPE$1][_enumBugKeys[i]];

    return createDict();
  };

  var _objectCreate =
    Object.create ||
    function create(O, Properties) {
      var result;

      if (O !== null) {
        Empty[PROTOTYPE$1] = _anObject(O);
        result = new Empty();
        Empty[PROTOTYPE$1] = null; // add "__proto__" for Object.getPrototypeOf polyfill

        result[IE_PROTO$1] = O;
      } else result = createDict();

      return Properties === undefined ? result : _objectDps(result, Properties);
    };

  var hiddenKeys = _enumBugKeys.concat("length", "prototype");

  var f$4 =
    Object.getOwnPropertyNames ||
    function getOwnPropertyNames(O) {
      return _objectKeysInternal(O, hiddenKeys);
    };

  var _objectGopn = {
    f: f$4,
  };

  var gOPN = _objectGopn.f;
  var toString$1 = {}.toString;
  var windowNames =
    typeof window == "object" && window && Object.getOwnPropertyNames
      ? Object.getOwnPropertyNames(window)
      : [];

  var getWindowNames = function (it) {
    try {
      return gOPN(it);
    } catch (e) {
      return windowNames.slice();
    }
  };

  var f$5 = function getOwnPropertyNames(it) {
    return windowNames && toString$1.call(it) == "[object Window]"
      ? getWindowNames(it)
      : gOPN(_toIobject(it));
  };

  var _objectGopnExt = {
    f: f$5,
  };

  var gOPD = Object.getOwnPropertyDescriptor;
  var f$6 = _descriptors
    ? gOPD
    : function getOwnPropertyDescriptor(O, P) {
        O = _toIobject(O);
        P = _toPrimitive(P, true);
        if (_ie8DomDefine)
          try {
            return gOPD(O, P);
          } catch (e) {
            /* empty */
          }
        if (_has(O, P)) return _propertyDesc(!_objectPie.f.call(O, P), O[P]);
      };
  var _objectGopd = {
    f: f$6,
  };

  var META = _meta.KEY;
  var gOPD$1 = _objectGopd.f;
  var dP$1 = _objectDp.f;
  var gOPN$1 = _objectGopnExt.f;
  var $Symbol = _global.Symbol;
  var $JSON = _global.JSON;

  var _stringify = $JSON && $JSON.stringify;

  var PROTOTYPE$2 = "prototype";
  var HIDDEN = _wks("_hidden");
  var TO_PRIMITIVE = _wks("toPrimitive");
  var isEnum = {}.propertyIsEnumerable;
  var SymbolRegistry = _shared("symbol-registry");
  var AllSymbols = _shared("symbols");
  var OPSymbols = _shared("op-symbols");
  var ObjectProto = Object[PROTOTYPE$2];
  var USE_NATIVE = typeof $Symbol == "function" && !!_objectGops.f;
  var QObject = _global.QObject; // Don't use setters in Qt Script,

  var setter =
    !QObject || !QObject[PROTOTYPE$2] || !QObject[PROTOTYPE$2].findChild; // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687

  var setSymbolDesc =
    _descriptors &&
    _fails(function () {
      return (
        _objectCreate(
          dP$1({}, "a", {
            get: function () {
              return dP$1(this, "a", {
                value: 7,
              }).a;
            },
          })
        ).a != 7
      );
    })
      ? function (it, key, D) {
          var protoDesc = gOPD$1(ObjectProto, key);
          if (protoDesc) delete ObjectProto[key];
          dP$1(it, key, D);
          if (protoDesc && it !== ObjectProto)
            dP$1(ObjectProto, key, protoDesc);
        }
      : dP$1;

  var wrap = function (tag) {
    var sym = (AllSymbols[tag] = _objectCreate($Symbol[PROTOTYPE$2]));

    sym._k = tag;
    return sym;
  };

  var isSymbol =
    USE_NATIVE && typeof $Symbol.iterator == "symbol"
      ? function (it) {
          return typeof it == "symbol";
        }
      : function (it) {
          return it instanceof $Symbol;
        };

  var $defineProperty = function defineProperty(it, key, D) {
    if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
    _anObject(it);
    key = _toPrimitive(key, true);
    _anObject(D);

    if (_has(AllSymbols, key)) {
      if (!D.enumerable) {
        if (!_has(it, HIDDEN)) dP$1(it, HIDDEN, _propertyDesc(1, {}));
        it[HIDDEN][key] = true;
      } else {
        if (_has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
        D = _objectCreate(D, {
          enumerable: _propertyDesc(0, false),
        });
      }

      return setSymbolDesc(it, key, D);
    }

    return dP$1(it, key, D);
  };

  var $defineProperties = function defineProperties(it, P) {
    _anObject(it);
    var keys = _enumKeys((P = _toIobject(P)));
    var i = 0;
    var l = keys.length;
    var key;

    while (l > i) $defineProperty(it, (key = keys[i++]), P[key]);

    return it;
  };

  var $create = function create(it, P) {
    return P === undefined
      ? _objectCreate(it)
      : $defineProperties(_objectCreate(it), P);
  };

  var $propertyIsEnumerable = function propertyIsEnumerable(key) {
    var E = isEnum.call(this, (key = _toPrimitive(key, true)));
    if (this === ObjectProto && _has(AllSymbols, key) && !_has(OPSymbols, key))
      return false;
    return E ||
      !_has(this, key) ||
      !_has(AllSymbols, key) ||
      (_has(this, HIDDEN) && this[HIDDEN][key])
      ? E
      : true;
  };

  var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
    it = _toIobject(it);
    key = _toPrimitive(key, true);
    if (it === ObjectProto && _has(AllSymbols, key) && !_has(OPSymbols, key))
      return;
    var D = gOPD$1(it, key);
    if (D && _has(AllSymbols, key) && !(_has(it, HIDDEN) && it[HIDDEN][key]))
      D.enumerable = true;
    return D;
  };

  var $getOwnPropertyNames = function getOwnPropertyNames(it) {
    var names = gOPN$1(_toIobject(it));
    var result = [];
    var i = 0;
    var key;

    while (names.length > i) {
      if (!_has(AllSymbols, (key = names[i++])) && key != HIDDEN && key != META)
        result.push(key);
    }

    return result;
  };

  var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
    var IS_OP = it === ObjectProto;
    var names = gOPN$1(IS_OP ? OPSymbols : _toIobject(it));
    var result = [];
    var i = 0;
    var key;

    while (names.length > i) {
      if (
        _has(AllSymbols, (key = names[i++])) &&
        (IS_OP ? _has(ObjectProto, key) : true)
      )
        result.push(AllSymbols[key]);
    }

    return result;
  }; // Symbol([description])

  if (!USE_NATIVE) {
    $Symbol = function Symbol() {
      if (this instanceof $Symbol)
        throw TypeError("Symbol is not a constructor!");
      var tag = _uid(arguments.length > 0 ? arguments[0] : undefined);

      var $set = function (value) {
        if (this === ObjectProto) $set.call(OPSymbols, value);
        if (_has(this, HIDDEN) && _has(this[HIDDEN], tag))
          this[HIDDEN][tag] = false;
        setSymbolDesc(this, tag, _propertyDesc(1, value));
      };

      if (_descriptors && setter)
        setSymbolDesc(ObjectProto, tag, {
          configurable: true,
          set: $set,
        });
      return wrap(tag);
    };

    _redefine($Symbol[PROTOTYPE$2], "toString", function toString() {
      return this._k;
    });
    _objectGopd.f = $getOwnPropertyDescriptor;
    _objectDp.f = $defineProperty;
    _objectGopn.f = _objectGopnExt.f = $getOwnPropertyNames;
    _objectPie.f = $propertyIsEnumerable;
    _objectGops.f = $getOwnPropertySymbols;

    if (_descriptors && !_library) {
      _redefine(
        ObjectProto,
        "propertyIsEnumerable",
        $propertyIsEnumerable,
        true
      );
    }

    _wksExt.f = function (name) {
      return wrap(_wks(name));
    };
  }

  _export(_export.G + _export.W + _export.F * !USE_NATIVE, {
    Symbol: $Symbol,
  });

  for (
    var es6Symbols = //
        "hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(
          ","
        ),
      j = 0;
    es6Symbols.length > j;

  )
    _wks(es6Symbols[j++]);

  for (
    var wellKnownSymbols = _objectKeys(_wks.store), k = 0;
    wellKnownSymbols.length > k;

  )
    _wksDefine(wellKnownSymbols[k++]);

  _export(_export.S + _export.F * !USE_NATIVE, "Symbol", {
    for: function (key) {
      return _has(SymbolRegistry, (key += ""))
        ? SymbolRegistry[key]
        : (SymbolRegistry[key] = $Symbol(key));
    },
    //  Symbol.keyFor(sym)
    keyFor: function keyFor(sym) {
      if (!isSymbol(sym)) throw TypeError(sym + " is not a symbol!");

      for (var key in SymbolRegistry)
        if (SymbolRegistry[key] === sym) return key;
    },
    useSetter: function () {
      setter = true;
    },
    useSimple: function () {
      setter = false;
    },
  });
  _export(_export.S + _export.F * !USE_NATIVE, "Object", {
    //  Object.create(O [, Properties])
    create: $create,
    //  Object.defineProperty(O, P, Attributes)
    defineProperty: $defineProperty,
    //  Object.defineProperties(O, Properties)
    defineProperties: $defineProperties,
    //  Object.getOwnPropertyDescriptor(O, P)
    getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
    //  Object.getOwnPropertyNames(O)
    getOwnPropertyNames: $getOwnPropertyNames,
    // Object.getOwnPropertySymbols(O)
    getOwnPropertySymbols: $getOwnPropertySymbols,
  }); // Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
  // https://bugs.chromium.org/p/v8/issues/detail?id=3443

  var FAILS_ON_PRIMITIVES = _fails(function () {
    _objectGops.f(1);
  });
  _export(_export.S + _export.F * FAILS_ON_PRIMITIVES, "Object", {
    getOwnPropertySymbols: function getOwnPropertySymbols(it) {
      return _objectGops.f(_toObject(it));
    },
  }); //  JSON.stringify(value [, replacer [, space]])

  $JSON &&
    _export(
      _export.S +
        _export.F *
          (!USE_NATIVE ||
            _fails(function () {
              var S = $Symbol(); // MS Edge converts symbol values to JSON as {}
              // WebKit converts symbol values to JSON as null
              // V8 throws on boxed symbols

              return (
                _stringify([S]) != "[null]" ||
                _stringify({
                  a: S,
                }) != "{}" ||
                _stringify(Object(S)) != "{}"
              );
            })),
      "JSON",
      {
        stringify: function stringify(it) {
          var args = [it];
          var i = 1;
          var replacer, $replacer;

          while (arguments.length > i) args.push(arguments[i++]);

          $replacer = replacer = args[1];
          if ((!_isObject(replacer) && it === undefined) || isSymbol(it))
            return; // IE8 returns string on undefined

          if (!_isArray(replacer))
            replacer = function (key, value) {
              if (typeof $replacer == "function")
                value = $replacer.call(this, key, value);
              if (!isSymbol(value)) return value;
            };
          args[1] = replacer;
          return _stringify.apply($JSON, args);
        },
      }
    ); // Symbol.prototype[@@toPrimitive](hint)

  $Symbol[PROTOTYPE$2][TO_PRIMITIVE] ||
    _hide($Symbol[PROTOTYPE$2], TO_PRIMITIVE, $Symbol[PROTOTYPE$2].valueOf); // Symbol.prototype[@@toStringTag]

  _setToStringTag($Symbol, "Symbol"); //  Math[@@toStringTag]

  _setToStringTag(Math, "Math", true); //  JSON[@@toStringTag]

  _setToStringTag(_global.JSON, "JSON", true);

  _export(_export.S, "Array", {
    isArray: _isArray,
  });

  _export(_export.S + _export.F * !_descriptors, "Object", {
    defineProperties: _objectDps,
  });

  _export(_export.S, "Object", {
    create: _objectCreate,
  });

  _objectSap("getOwnPropertyNames", function () {
    return _objectGopnExt.f;
  });

  var $getOwnPropertyDescriptor$1 = _objectGopd.f;
  _objectSap("getOwnPropertyDescriptor", function () {
    return function getOwnPropertyDescriptor(it, key) {
      return $getOwnPropertyDescriptor$1(_toIobject(it), key);
    };
  });

  var IE_PROTO$2 = _sharedKey("IE_PROTO");
  var ObjectProto$1 = Object.prototype;

  var _objectGpo =
    Object.getPrototypeOf ||
    function (O) {
      O = _toObject(O);
      if (_has(O, IE_PROTO$2)) return O[IE_PROTO$2];

      if (typeof O.constructor == "function" && O instanceof O.constructor) {
        return O.constructor.prototype;
      }

      return O instanceof Object ? ObjectProto$1 : null;
    };

  _objectSap("getPrototypeOf", function () {
    return function getPrototypeOf(it) {
      return _objectGpo(_toObject(it));
    };
  });

  var SPECIES$2 = _wks("species");

  var _arraySpeciesConstructor = function (original) {
    var C;

    if (_isArray(original)) {
      C = original.constructor; // cross-realm fallback

      if (typeof C == "function" && (C === Array || _isArray(C.prototype)))
        C = undefined;

      if (_isObject(C)) {
        C = C[SPECIES$2];
        if (C === null) C = undefined;
      }
    }

    return C === undefined ? Array : C;
  };

  var _arraySpeciesCreate = function (original, length) {
    return new (_arraySpeciesConstructor(original))(length);
  };

  // 1 -> Array#map
  // 2 -> Array#filter
  // 3 -> Array#some
  // 4 -> Array#every
  // 5 -> Array#find
  // 6 -> Array#findIndex

  var _arrayMethods = function (TYPE, $create) {
    var IS_MAP = TYPE == 1;
    var IS_FILTER = TYPE == 2;
    var IS_SOME = TYPE == 3;
    var IS_EVERY = TYPE == 4;
    var IS_FIND_INDEX = TYPE == 6;
    var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
    var create = $create || _arraySpeciesCreate;
    return function ($this, callbackfn, that) {
      var O = _toObject($this);
      var self = _iobject(O);
      var f = _ctx(callbackfn, that, 3);
      var length = _toLength(self.length);
      var index = 0;
      var result = IS_MAP
        ? create($this, length)
        : IS_FILTER
        ? create($this, 0)
        : undefined;
      var val, res;

      for (; length > index; index++)
        if (NO_HOLES || index in self) {
          val = self[index];
          res = f(val, index, O);

          if (TYPE) {
            if (IS_MAP) result[index] = res; // map
            else if (res)
              switch (TYPE) {
                case 3:
                  return true;
                // some

                case 5:
                  return val;
                // find

                case 6:
                  return index;
                // findIndex

                case 2:
                  result.push(val);
                // filter
              }
            else if (IS_EVERY) return false; // every
          }
        }

      return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
    };
  };

  var _strictMethod = function (method, arg) {
    return (
      !!method &&
      _fails(function () {
        // eslint-disable-next-line no-useless-call
        arg
          ? method.call(
              null,
              function () {
                /* empty */
              },
              1
            )
          : method.call(null);
      })
    );
  };

  var $forEach = _arrayMethods(0);
  var STRICT = _strictMethod([].forEach, true);
  _export(_export.P + _export.F * !STRICT, "Array", {
    // Array.prototype.forEach(callbackfn [, thisArg])
    forEach: function forEach(
      callbackfn
      /* , thisArg */
    ) {
      return $forEach(this, callbackfn, arguments[1]);
    },
  });

  // SameValue(x, y)
  var _sameValue =
    Object.is ||
    function is(x, y) {
      // eslint-disable-next-line no-self-compare
      return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
    };

  _export(_export.S, "Object", {
    is: _sameValue,
  });

  /* eslint-disable no-proto */

  var check = function (O, proto) {
    _anObject(O);
    if (!_isObject(proto) && proto !== null)
      throw TypeError(proto + ": can't set as prototype!");
  };

  var _setProto = {
    set:
      Object.setPrototypeOf ||
      ("__proto__" in {} // eslint-disable-line
        ? (function (test, buggy, set) {
            try {
              set = _ctx(
                Function.call,
                _objectGopd.f(Object.prototype, "__proto__").set,
                2
              );
              set(test, []);
              buggy = !(test instanceof Array);
            } catch (e) {
              buggy = true;
            }

            return function setPrototypeOf(O, proto) {
              check(O, proto);
              if (buggy) O.__proto__ = proto;
              else set(O, proto);
              return O;
            };
          })({}, false)
        : undefined),
    check: check,
  };

  _export(_export.S, "Object", {
    setPrototypeOf: _setProto.set,
  });

  // fast apply,
  var _invoke = function (fn, args, that) {
    var un = that === undefined;

    switch (args.length) {
      case 0:
        return un ? fn() : fn.call(that);

      case 1:
        return un ? fn(args[0]) : fn.call(that, args[0]);

      case 2:
        return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);

      case 3:
        return un
          ? fn(args[0], args[1], args[2])
          : fn.call(that, args[0], args[1], args[2]);

      case 4:
        return un
          ? fn(args[0], args[1], args[2], args[3])
          : fn.call(that, args[0], args[1], args[2], args[3]);
    }

    return fn.apply(that, args);
  };

  var arraySlice$1 = [].slice;
  var factories = {};

  var construct = function (F, len, args) {
    if (!(len in factories)) {
      for (var n = [], i = 0; i < len; i++) n[i] = "a[" + i + "]"; // eslint-disable-next-line no-new-func

      factories[len] = Function("F,a", "return new F(" + n.join(",") + ")");
    }

    return factories[len](F, args);
  };

  var _bind =
    Function.bind ||
    function bind(
      that
      /* , ...args */
    ) {
      var fn = _aFunction(this);
      var partArgs = arraySlice$1.call(arguments, 1);

      var bound = function () /* args... */
      {
        var args = partArgs.concat(arraySlice$1.call(arguments));
        return this instanceof bound
          ? construct(fn, args.length, args)
          : _invoke(fn, args, that);
      };

      if (_isObject(fn.prototype)) bound.prototype = fn.prototype;
      return bound;
    };

  _export(_export.P, "Function", {
    bind: _bind,
  });

  var dP$2 = _objectDp.f;
  var FProto = Function.prototype;
  var nameRE = /^\s*function ([^ (]*)/;
  var NAME = "name";

  NAME in FProto ||
    (_descriptors &&
      dP$2(FProto, NAME, {
        configurable: true,
        get: function () {
          try {
            return ("" + this).match(nameRE)[1];
          } catch (e) {
            return "";
          }
        },
      }));

  _fixReWks("match", 1, function (defined, MATCH, $match, maybeCallNative) {
    return [
      // `String.prototype.match` method

      function match(regexp) {
        var O = defined(this);
        var fn = regexp == undefined ? undefined : regexp[MATCH];
        return fn !== undefined
          ? fn.call(regexp, O)
          : new RegExp(regexp)[MATCH](String(O));
      }, // `RegExp.prototype[@@match]` method

      function (regexp) {
        var res = maybeCallNative($match, regexp, this);
        if (res.done) return res.value;
        var rx = _anObject(regexp);
        var S = String(this);
        if (!rx.global) return _regexpExecAbstract(rx, S);
        var fullUnicode = rx.unicode;
        rx.lastIndex = 0;
        var A = [];
        var n = 0;
        var result;

        while ((result = _regexpExecAbstract(rx, S)) !== null) {
          var matchStr = String(result[0]);
          A[n] = matchStr;
          if (matchStr === "")
            rx.lastIndex = _advanceStringIndex(
              S,
              _toLength(rx.lastIndex),
              fullUnicode
            );
          n++;
        }

        return n === 0 ? null : A;
      },
    ];
  });

  var setPrototypeOf = _setProto.set;

  var _inheritIfRequired = function (that, target, C) {
    var S = target.constructor;
    var P;

    if (
      S !== C &&
      typeof S == "function" &&
      (P = S.prototype) !== C.prototype &&
      _isObject(P) &&
      setPrototypeOf
    ) {
      setPrototypeOf(that, P);
    }

    return that;
  };

  var SPECIES$3 = _wks("species");

  var _setSpecies = function (KEY) {
    var C = _global[KEY];
    if (_descriptors && C && !C[SPECIES$3])
      _objectDp.f(C, SPECIES$3, {
        configurable: true,
        get: function () {
          return this;
        },
      });
  };

  var dP$3 = _objectDp.f;
  var gOPN$2 = _objectGopn.f;
  var $RegExp = _global.RegExp;
  var Base = $RegExp;
  var proto = $RegExp.prototype;
  var re1 = /a/g;
  var re2 = /a/g; // "new" creates a new object, old webkit buggy here

  var CORRECT_NEW = new $RegExp(re1) !== re1;

  if (
    _descriptors &&
    (!CORRECT_NEW ||
      _fails(function () {
        re2[_wks("match")] = false; // RegExp constructor can alter flags and IsRegExp works correct with @@match

        return (
          $RegExp(re1) != re1 ||
          $RegExp(re2) == re2 ||
          $RegExp(re1, "i") != "/a/i"
        );
      }))
  ) {
    $RegExp = function RegExp(p, f) {
      var tiRE = this instanceof $RegExp;
      var piRE = _isRegexp(p);
      var fiU = f === undefined;
      return !tiRE && piRE && p.constructor === $RegExp && fiU
        ? p
        : _inheritIfRequired(
            CORRECT_NEW
              ? new Base(piRE && !fiU ? p.source : p, f)
              : Base(
                  (piRE = p instanceof $RegExp) ? p.source : p,
                  piRE && fiU ? _flags.call(p) : f
                ),
            tiRE ? this : proto,
            $RegExp
          );
    };

    var proxy = function (key) {
      key in $RegExp ||
        dP$3($RegExp, key, {
          configurable: true,
          get: function () {
            return Base[key];
          },
          set: function (it) {
            Base[key] = it;
          },
        });
    };

    for (var keys = gOPN$2(Base), i = 0; keys.length > i; ) proxy(keys[i++]);

    proto.constructor = $RegExp;
    $RegExp.prototype = proto;
    _redefine(_global, "RegExp", $RegExp);
  }

  _setSpecies("RegExp");

  var _stringWs =
    "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" +
    "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF";

  var space = "[" + _stringWs + "]";
  var non = "\u200b\u0085";
  var ltrim = RegExp("^" + space + space + "*");
  var rtrim = RegExp(space + space + "*$");

  var exporter = function (KEY, exec, ALIAS) {
    var exp = {};
    var FORCE = _fails(function () {
      return !!_stringWs[KEY]() || non[KEY]() != non;
    });
    var fn = (exp[KEY] = FORCE ? exec(trim) : _stringWs[KEY]);
    if (ALIAS) exp[ALIAS] = fn;
    _export(_export.P + _export.F * FORCE, "String", exp);
  }; // 1 -> String#trimLeft
  // 2 -> String#trimRight
  // 3 -> String#trim

  var trim = (exporter.trim = function (string, TYPE) {
    string = String(_defined(string));
    if (TYPE & 1) string = string.replace(ltrim, "");
    if (TYPE & 2) string = string.replace(rtrim, "");
    return string;
  });

  var _stringTrim = exporter;

  _stringTrim("trim", function ($trim) {
    return function trim() {
      return $trim(this, 3);
    };
  });

  var max$1 = Math.max;
  var min$2 = Math.min;
  var floor$1 = Math.floor;
  var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g;
  var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g;

  var maybeToString = function (it) {
    return it === undefined ? it : String(it);
  }; // @@replace logic

  _fixReWks(
    "replace",
    2,
    function (defined, REPLACE, $replace, maybeCallNative) {
      return [
        // `String.prototype.replace` method

        function replace(searchValue, replaceValue) {
          var O = defined(this);
          var fn = searchValue == undefined ? undefined : searchValue[REPLACE];
          return fn !== undefined
            ? fn.call(searchValue, O, replaceValue)
            : $replace.call(String(O), searchValue, replaceValue);
        }, // `RegExp.prototype[@@replace]` method

        function (regexp, replaceValue) {
          var res = maybeCallNative($replace, regexp, this, replaceValue);
          if (res.done) return res.value;
          var rx = _anObject(regexp);
          var S = String(this);
          var functionalReplace = typeof replaceValue === "function";
          if (!functionalReplace) replaceValue = String(replaceValue);
          var global = rx.global;

          if (global) {
            var fullUnicode = rx.unicode;
            rx.lastIndex = 0;
          }

          var results = [];

          while (true) {
            var result = _regexpExecAbstract(rx, S);
            if (result === null) break;
            results.push(result);
            if (!global) break;
            var matchStr = String(result[0]);
            if (matchStr === "")
              rx.lastIndex = _advanceStringIndex(
                S,
                _toLength(rx.lastIndex),
                fullUnicode
              );
          }

          var accumulatedResult = "";
          var nextSourcePosition = 0;

          for (var i = 0; i < results.length; i++) {
            result = results[i];
            var matched = String(result[0]);
            var position = max$1(min$2(_toInteger(result.index), S.length), 0);
            var captures = []; // NOTE: This is equivalent to
            //   captures = result.slice(1).map(maybeToString)
            // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
            // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
            // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.

            for (var j = 1; j < result.length; j++)
              captures.push(maybeToString(result[j]));

            var namedCaptures = result.groups;

            if (functionalReplace) {
              var replacerArgs = [matched].concat(captures, position, S);
              if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
              var replacement = String(
                replaceValue.apply(undefined, replacerArgs)
              );
            } else {
              replacement = getSubstitution(
                matched,
                S,
                position,
                captures,
                namedCaptures,
                replaceValue
              );
            }

            if (position >= nextSourcePosition) {
              accumulatedResult +=
                S.slice(nextSourcePosition, position) + replacement;
              nextSourcePosition = position + matched.length;
            }
          }

          return accumulatedResult + S.slice(nextSourcePosition);
        },
      ];

      function getSubstitution(
        matched,
        str,
        position,
        captures,
        namedCaptures,
        replacement
      ) {
        var tailPos = position + matched.length;
        var m = captures.length;
        var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;

        if (namedCaptures !== undefined) {
          namedCaptures = _toObject(namedCaptures);
          symbols = SUBSTITUTION_SYMBOLS;
        }

        return $replace.call(replacement, symbols, function (match, ch) {
          var capture;

          switch (ch.charAt(0)) {
            case "$":
              return "$";

            case "&":
              return matched;

            case "`":
              return str.slice(0, position);

            case "'":
              return str.slice(tailPos);

            case "<":
              capture = namedCaptures[ch.slice(1, -1)];
              break;

            default:
              // \d\d?
              var n = +ch;
              if (n === 0) return match;

              if (n > m) {
                var f = floor$1(n / 10);
                if (f === 0) return match;
                if (f <= m)
                  return captures[f - 1] === undefined
                    ? ch.charAt(1)
                    : captures[f - 1] + ch.charAt(1);
                return match;
              }

              capture = captures[n - 1];
          }

          return capture === undefined ? "" : capture;
        });
      }
    }
  );

  var $parseFloat = _global.parseFloat;
  var $trim = _stringTrim.trim;

  var _parseFloat =
    1 / $parseFloat(_stringWs + "-0") !== -Infinity
      ? function parseFloat(str) {
          var string = $trim(String(str), 3);
          var result = $parseFloat(string);
          return result === 0 && string.charAt(0) == "-" ? -0 : result;
        }
      : $parseFloat;

  _export(
    _export.S + _export.F * (Number.parseFloat != _parseFloat),
    "Number",
    {
      parseFloat: _parseFloat,
    }
  );

  var gOPN$3 = _objectGopn.f;
  var gOPD$2 = _objectGopd.f;
  var dP$4 = _objectDp.f;
  var $trim$1 = _stringTrim.trim;
  var NUMBER = "Number";
  var $Number = _global[NUMBER];
  var Base$1 = $Number;
  var proto$1 = $Number.prototype; // Opera ~12 has broken Object#toString

  var BROKEN_COF = _cof(_objectCreate(proto$1)) == NUMBER;
  var TRIM = "trim" in String.prototype;

  var toNumber = function (argument) {
    var it = _toPrimitive(argument, false);

    if (typeof it == "string" && it.length > 2) {
      it = TRIM ? it.trim() : $trim$1(it, 3);
      var first = it.charCodeAt(0);
      var third, radix, maxCode;

      if (first === 43 || first === 45) {
        third = it.charCodeAt(2);
        if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
      } else if (first === 48) {
        switch (it.charCodeAt(1)) {
          case 66:
          case 98:
            radix = 2;
            maxCode = 49;
            break;
          // fast equal /^0b[01]+$/i

          case 79:
          case 111:
            radix = 8;
            maxCode = 55;
            break;
          // fast equal /^0o[0-7]+$/i

          default:
            return +it;
        }

        for (
          var digits = it.slice(2), i = 0, l = digits.length, code;
          i < l;
          i++
        ) {
          code = digits.charCodeAt(i); // parseInt parses a string to a first unavailable symbol
          // but ToNumber should return NaN if a string contains unavailable symbols

          if (code < 48 || code > maxCode) return NaN;
        }

        return parseInt(digits, radix);
      }
    }

    return +it;
  };

  if (!$Number(" 0o1") || !$Number("0b1") || $Number("+0x1")) {
    $Number = function Number(value) {
      var it = arguments.length < 1 ? 0 : value;
      var that = this;
      return that instanceof $Number && // check on 1..constructor(foo) case
        (BROKEN_COF
          ? _fails(function () {
              proto$1.valueOf.call(that);
            })
          : _cof(that) != NUMBER)
        ? _inheritIfRequired(new Base$1(toNumber(it)), that, $Number)
        : toNumber(it);
    };

    for (
      var keys$1 = _descriptors
          ? gOPN$3(Base$1)
          : // ES3:
            (
              "MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY," + // ES6 (in case, if modules with ES6 Number statics required before):
              "EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER," +
              "MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger"
            ).split(","),
        j$1 = 0,
        key;
      keys$1.length > j$1;
      j$1++
    ) {
      if (_has(Base$1, (key = keys$1[j$1])) && !_has($Number, key)) {
        dP$4($Number, key, gOPD$2(Base$1, key));
      }
    }

    $Number.prototype = proto$1;
    proto$1.constructor = $Number;
    _redefine(_global, NUMBER, $Number);
  }

  var $parseInt = _global.parseInt;
  var $trim$2 = _stringTrim.trim;
  var hex = /^[-+]?0[xX]/;

  var _parseInt =
    $parseInt(_stringWs + "08") !== 8 || $parseInt(_stringWs + "0x16") !== 22
      ? function parseInt(str, radix) {
          var string = $trim$2(String(str), 3);
          return $parseInt(string, radix >>> 0 || (hex.test(string) ? 16 : 10));
        }
      : $parseInt;

  _export(_export.S + _export.F * (Number.parseInt != _parseInt), "Number", {
    parseInt: _parseInt,
  });

  var _mathLog1p =
    Math.log1p ||
    function log1p(x) {
      return (x = +x) > -1e-8 && x < 1e-8 ? x - (x * x) / 2 : Math.log(1 + x);
    };

  _export(_export.S, "Math", {
    log1p: _mathLog1p,
  });

  var sqrt = Math.sqrt;
  var $acosh = Math.acosh;
  _export(
    _export.S +
      _export.F *
        !(
          $acosh && // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
          Math.floor($acosh(Number.MAX_VALUE)) == 710 && // Tor Browser bug: Math.acosh(Infinity) -> NaN
          $acosh(Infinity) == Infinity
        ),
    "Math",
    {
      acosh: function acosh(x) {
        return (x = +x) < 1
          ? NaN
          : x > 94906265.62425156
          ? Math.log(x) + Math.LN2
          : _mathLog1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
      },
    }
  );

  var $asinh = Math.asinh;

  function asinh(x) {
    return !isFinite((x = +x)) || x == 0
      ? x
      : x < 0
      ? -asinh(-x)
      : Math.log(x + Math.sqrt(x * x + 1));
  } // Tor Browser bug: Math.asinh(0) -> -0

  _export(_export.S + _export.F * !($asinh && 1 / $asinh(0) > 0), "Math", {
    asinh: asinh,
  });

  var $atanh = Math.atanh; // Tor Browser bug: Math.atanh(-0) -> 0

  _export(_export.S + _export.F * !($atanh && 1 / $atanh(-0) < 0), "Math", {
    atanh: function atanh(x) {
      return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;
    },
  });

  var _mathSign =
    Math.sign ||
    function sign(x) {
      // eslint-disable-next-line no-self-compare
      return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
    };

  _export(_export.S, "Math", {
    sign: _mathSign,
  });

  var $expm1 = Math.expm1;

  var _mathExpm1 =
    !$expm1 || // Old FF bug
    $expm1(10) > 22025.465794806719 ||
    $expm1(10) < 22025.4657948067165168 || // Tor Browser bug
    $expm1(-2e-17) != -2e-17
      ? function expm1(x) {
          return (x = +x) == 0
            ? x
            : x > -1e-6 && x < 1e-6
            ? x + (x * x) / 2
            : Math.exp(x) - 1;
        }
      : $expm1;

  _export(_export.S + _export.F * (_mathExpm1 != Math.expm1), "Math", {
    expm1: _mathExpm1,
  });

  var pow = Math.pow;
  var EPSILON = pow(2, -52);
  var EPSILON32 = pow(2, -23);
  var MAX32 = pow(2, 127) * (2 - EPSILON32);
  var MIN32 = pow(2, -126);

  var roundTiesToEven = function (n) {
    return n + 1 / EPSILON - 1 / EPSILON;
  };

  var _mathFround =
    Math.fround ||
    function fround(x) {
      var $abs = Math.abs(x);
      var $sign = _mathSign(x);
      var a, result;
      if ($abs < MIN32)
        return (
          $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32
        );
      a = (1 + EPSILON32 / EPSILON) * $abs;
      result = a - (a - $abs); // eslint-disable-next-line no-self-compare

      if (result > MAX32 || result != result) return $sign * Infinity;
      return $sign * result;
    };

  _export(_export.S, "Math", {
    fround: _mathFround,
  });

  var $imul = Math.imul; // some WebKit versions fails with big numbers, some has wrong arity

  _export(
    _export.S +
      _export.F *
        _fails(function () {
          return $imul(0xffffffff, 5) != -5 || $imul.length != 2;
        }),
    "Math",
    {
      imul: function imul(x, y) {
        var UINT16 = 0xffff;
        var xn = +x;
        var yn = +y;
        var xl = UINT16 & xn;
        var yl = UINT16 & yn;
        return (
          0 |
          (xl * yl +
            ((((UINT16 & (xn >>> 16)) * yl + xl * (UINT16 & (yn >>> 16))) <<
              16) >>>
              0))
        );
      },
    }
  );

  var exp = Math.exp; // V8 near Chromium 38 has a problem with very small numbers

  _export(
    _export.S +
      _export.F *
        _fails(function () {
          return !Math.sinh(-2e-17) != -2e-17;
        }),
    "Math",
    {
      sinh: function sinh(x) {
        return Math.abs((x = +x)) < 1
          ? (_mathExpm1(x) - _mathExpm1(-x)) / 2
          : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2);
      },
    }
  );

  var fromCharCode = String.fromCharCode;
  var $fromCodePoint = String.fromCodePoint; // length should be 1, old FF problem

  _export(
    _export.S + _export.F * (!!$fromCodePoint && $fromCodePoint.length != 1),
    "String",
    {
      fromCodePoint: function fromCodePoint(x) {
        // eslint-disable-line no-unused-vars
        var res = [];
        var aLen = arguments.length;
        var i = 0;
        var code;

        while (aLen > i) {
          code = +arguments[i++];
          if (_toAbsoluteIndex(code, 0x10ffff) !== code)
            throw RangeError(code + " is not a valid code point");
          res.push(
            code < 0x10000
              ? fromCharCode(code)
              : fromCharCode(
                  ((code -= 0x10000) >> 10) + 0xd800,
                  (code % 0x400) + 0xdc00
                )
          );
        }

        return res.join("");
      },
    }
  );

  var UNSCOPABLES = _wks("unscopables");
  var ArrayProto = Array.prototype;
  if (ArrayProto[UNSCOPABLES] == undefined) _hide(ArrayProto, UNSCOPABLES, {});

  var _addToUnscopables = function (key) {
    ArrayProto[UNSCOPABLES][key] = true;
  };

  var _iterStep = function (done, value) {
    return {
      value: value,
      done: !!done,
    };
  };

  var _iterators = {};

  var IteratorPrototype = {}; // %IteratorPrototype%[@@iterator]()

  _hide(IteratorPrototype, _wks("iterator"), function () {
    return this;
  });

  var _iterCreate = function (Constructor, NAME, next) {
    Constructor.prototype = _objectCreate(IteratorPrototype, {
      next: _propertyDesc(1, next),
    });
    _setToStringTag(Constructor, NAME + " Iterator");
  };

  var ITERATOR = _wks("iterator");
  var BUGGY = !([].keys && "next" in [].keys()); // Safari has buggy iterators w/o `next`

  var FF_ITERATOR = "@@iterator";
  var KEYS = "keys";
  var VALUES = "values";

  var returnThis = function () {
    return this;
  };

  var _iterDefine = function (
    Base,
    NAME,
    Constructor,
    next,
    DEFAULT,
    IS_SET,
    FORCED
  ) {
    _iterCreate(Constructor, NAME, next);

    var getMethod = function (kind) {
      if (!BUGGY && kind in proto) return proto[kind];

      switch (kind) {
        case KEYS:
          return function keys() {
            return new Constructor(this, kind);
          };

        case VALUES:
          return function values() {
            return new Constructor(this, kind);
          };
      }

      return function entries() {
        return new Constructor(this, kind);
      };
    };

    var TAG = NAME + " Iterator";
    var DEF_VALUES = DEFAULT == VALUES;
    var VALUES_BUG = false;
    var proto = Base.prototype;
    var $native =
      proto[ITERATOR] || proto[FF_ITERATOR] || (DEFAULT && proto[DEFAULT]);
    var $default = $native || getMethod(DEFAULT);
    var $entries = DEFAULT
      ? !DEF_VALUES
        ? $default
        : getMethod("entries")
      : undefined;
    var $anyNative = NAME == "Array" ? proto.entries || $native : $native;
    var methods, key, IteratorPrototype; // Fix native

    if ($anyNative) {
      IteratorPrototype = _objectGpo($anyNative.call(new Base()));

      if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
        // Set @@toStringTag to native iterators
        _setToStringTag(IteratorPrototype, TAG, true); // fix for some old engines

        if (typeof IteratorPrototype[ITERATOR] != "function")
          _hide(IteratorPrototype, ITERATOR, returnThis);
      }
    } // fix Array#{values, @@iterator}.name in V8 / FF

    if (DEF_VALUES && $native && $native.name !== VALUES) {
      VALUES_BUG = true;

      $default = function values() {
        return $native.call(this);
      };
    } // Define iterator

    if (BUGGY || VALUES_BUG || !proto[ITERATOR]) {
      _hide(proto, ITERATOR, $default);
    } // Plug for library

    _iterators[NAME] = $default;
    _iterators[TAG] = returnThis;

    if (DEFAULT) {
      methods = {
        values: DEF_VALUES ? $default : getMethod(VALUES),
        keys: IS_SET ? $default : getMethod(KEYS),
        entries: $entries,
      };
      if (FORCED)
        for (key in methods) {
          if (!(key in proto)) _redefine(proto, key, methods[key]);
        }
      else
        _export(_export.P + _export.F * (BUGGY || VALUES_BUG), NAME, methods);
    }

    return methods;
  };


  var es6_array_iterator = _iterDefine(
    Array,
    "Array",
    function (iterated, kind) {
      this._t = _toIobject(iterated); // target

      this._i = 0; // next index

      this._k = kind; // kind

    },
    function () {
      var O = this._t;
      var kind = this._k;
      var index = this._i++;

      if (!O || index >= O.length) {
        this._t = undefined;
        return _iterStep(1);
      }

      if (kind == "keys") return _iterStep(0, index);
      if (kind == "values") return _iterStep(0, O[index]);
      return _iterStep(0, [index, O[index]]);
    },
    "values"
  ); // argumentsList[@@iterator] is %ArrayProto_values%

  _iterators.Arguments = _iterators.Array;
  _addToUnscopables("keys");
  _addToUnscopables("values");
  _addToUnscopables("entries");

  var ITERATOR$1 = _wks("iterator");
  var TO_STRING_TAG = _wks("toStringTag");
  var ArrayValues = _iterators.Array;
  var DOMIterables = {
    CSSRuleList: true,
    // TODO: Not spec compliant, should be false.
    CSSStyleDeclaration: false,
    CSSValueList: false,
    ClientRectList: false,
    DOMRectList: false,
    DOMStringList: false,
    DOMTokenList: true,
    DataTransferItemList: false,
    FileList: false,
    HTMLAllCollection: false,
    HTMLCollection: false,
    HTMLFormElement: false,
    HTMLSelectElement: false,
    MediaList: true,
    // TODO: Not spec compliant, should be false.
    MimeTypeArray: false,
    NamedNodeMap: false,
    NodeList: true,
    PaintRequestList: false,
    Plugin: false,
    PluginArray: false,
    SVGLengthList: false,
    SVGNumberList: false,
    SVGPathSegList: false,
    SVGPointList: false,
    SVGStringList: false,
    SVGTransformList: false,
    SourceBufferList: false,
    StyleSheetList: true,
    // TODO: Not spec compliant, should be false.
    TextTrackCueList: false,
    TextTrackList: false,
    TouchList: false,
  };

  for (
    var collections = _objectKeys(DOMIterables), i$1 = 0;
    i$1 < collections.length;
    i$1++
  ) {
    var NAME$1 = collections[i$1];
    var explicit = DOMIterables[NAME$1];
    var Collection = _global[NAME$1];
    var proto$2 = Collection && Collection.prototype;
    var key$1;

    if (proto$2) {
      if (!proto$2[ITERATOR$1]) _hide(proto$2, ITERATOR$1, ArrayValues);
      if (!proto$2[TO_STRING_TAG]) _hide(proto$2, TO_STRING_TAG, NAME$1);
      _iterators[NAME$1] = ArrayValues;
      if (explicit)
        for (key$1 in es6_array_iterator)
          if (!proto$2[key$1])
            _redefine(proto$2, key$1, es6_array_iterator[key$1], true);
    }
  }

  var _stringContext = function (that, searchString, NAME) {
    if (_isRegexp(searchString))
      throw TypeError("String#" + NAME + " doesn't accept regex!");
    return String(_defined(that));
  };

  var MATCH$1 = _wks("match");

  var _failsIsRegexp = function (KEY) {
    var re = /./;

    try {
      "/./"[KEY](re);
    } catch (e) {
      try {
        re[MATCH$1] = false;
        return !"/./"[KEY](re);
      } catch (f) {
        /* empty */
      }
    }

    return true;
  };

  var ENDS_WITH = "endsWith";
  var $endsWith = ""[ENDS_WITH];
  _export(_export.P + _export.F * _failsIsRegexp(ENDS_WITH), "String", {
    endsWith: function endsWith(
      searchString
      /* , endPosition = @length */
    ) {
      var that = _stringContext(this, searchString, ENDS_WITH);
      var endPosition = arguments.length > 1 ? arguments[1] : undefined;
      var len = _toLength(that.length);
      var end =
        endPosition === undefined ? len : Math.min(_toLength(endPosition), len);
      var search = String(searchString);
      return $endsWith
        ? $endsWith.call(that, search, end)
        : that.slice(end - search.length, end) === search;
    },
  });

  var $indexOf = _arrayIncludes(false);
  var $native = [].indexOf;
  var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;
  _export(
    _export.P + _export.F * (NEGATIVE_ZERO || !_strictMethod($native)),
    "Array",
    {
      // Array.prototype.indexOf(searchElement [, fromIndex])
      indexOf: function indexOf(
        searchElement
        /* , fromIndex = 0 */
      ) {
        return NEGATIVE_ZERO // convert -0 to +0
          ? $native.apply(this, arguments) || 0
          : $indexOf(this, searchElement, arguments[1]);
      },
    }
  );

  var STARTS_WITH = "startsWith";
  var $startsWith = ""[STARTS_WITH];
  _export(_export.P + _export.F * _failsIsRegexp(STARTS_WITH), "String", {
    startsWith: function startsWith(
      searchString
      /* , position = 0 */
    ) {
      var that = _stringContext(this, searchString, STARTS_WITH);
      var index = _toLength(
        Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length)
      );
      var search = String(searchString);
      return $startsWith
        ? $startsWith.call(that, search, index)
        : that.slice(index, index + search.length) === search;
    },
  });

  _export(
    _export.P +
      _export.F *
        _fails(function () {
          return (
            new Date(NaN).toJSON() !== null ||
            Date.prototype.toJSON.call({
              toISOString: function () {
                return 1;
              },
            }) !== 1
          );
        }),
    "Date",
    {
      // eslint-disable-next-line no-unused-vars
      toJSON: function toJSON(key) {
        var O = _toObject(this);
        var pv = _toPrimitive(O);
        return typeof pv == "number" && !isFinite(pv) ? null : O.toISOString();
      },
    }
  );

  var getTime$1 = Date.prototype.getTime;
  var $toISOString = Date.prototype.toISOString;

  var lz = function (num) {
    return num > 9 ? num : "0" + num;
  }; // PhantomJS / old WebKit has a broken implementations

  var _dateToIsoString =
    _fails(function () {
      return (
        $toISOString.call(new Date(-5e13 - 1)) != "0385-07-25T07:06:39.999Z"
      );
    }) ||
    !_fails(function () {
      $toISOString.call(new Date(NaN));
    })
      ? function toISOString() {
          if (!isFinite(getTime$1.call(this)))
            throw RangeError("Invalid time value");
          var d = this;
          var y = d.getUTCFullYear();
          var m = d.getUTCMilliseconds();
          var s = y < 0 ? "-" : y > 9999 ? "+" : "";
          return (
            s +
            ("00000" + Math.abs(y)).slice(s ? -6 : -4) +
            "-" +
            lz(d.getUTCMonth() + 1) +
            "-" +
            lz(d.getUTCDate()) +
            "T" +
            lz(d.getUTCHours()) +
            ":" +
            lz(d.getUTCMinutes()) +
            ":" +
            lz(d.getUTCSeconds()) +
            "." +
            (m > 99 ? m : "0" + lz(m)) +
            "Z"
          );
        }
      : $toISOString;

  // PhantomJS / old WebKit has a broken implementations

  _export(
    _export.P + _export.F * (Date.prototype.toISOString !== _dateToIsoString),
    "Date",
    {
      toISOString: _dateToIsoString,
    }
  );

  var _iterCall = function (iterator, fn, value, entries) {
    try {
      return entries ? fn(_anObject(value)[0], value[1]) : fn(value); // IteratorClose(iterator, completion)
    } catch (e) {
      var ret = iterator["return"];
      if (ret !== undefined) _anObject(ret.call(iterator));
      throw e;
    }
  };

  var ITERATOR$2 = _wks("iterator");
  var ArrayProto$1 = Array.prototype;

  var _isArrayIter = function (it) {
    return (
      it !== undefined &&
      (_iterators.Array === it || ArrayProto$1[ITERATOR$2] === it)
    );
  };

  var _createProperty = function (object, index, value) {
    if (index in object) _objectDp.f(object, index, _propertyDesc(0, value));
    else object[index] = value;
  };

  var ITERATOR$3 = _wks("iterator");

  var core_getIteratorMethod = (_core.getIteratorMethod = function (it) {
    if (it != undefined)
      return it[ITERATOR$3] || it["@@iterator"] || _iterators[_classof(it)];
  });

  var ITERATOR$4 = _wks("iterator");
  var SAFE_CLOSING = false;

  try {
    var riter = [7][ITERATOR$4]();

    riter["return"] = function () {
      SAFE_CLOSING = true;
    }; // eslint-disable-next-line no-throw-literal

    Array.from(riter, function () {
      throw 2;
    });
  } catch (e) {
    /* empty */
  }

  var _iterDetect = function (exec, skipClosing) {
    if (!skipClosing && !SAFE_CLOSING) return false;
    var safe = false;

    try {
      var arr = [7];
      var iter = arr[ITERATOR$4]();

      iter.next = function () {
        return {
          done: (safe = true),
        };
      };

      arr[ITERATOR$4] = function () {
        return iter;
      };

      exec(arr);
    } catch (e) {
      /* empty */
    }

    return safe;
  };

  _export(
    _export.S +
      _export.F *
        !_iterDetect(function (iter) {
          Array.from(iter);
        }),
    "Array",
    {
      // Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
      from: function from(
        arrayLike
        /* , mapfn = undefined, thisArg = undefined */
      ) {
        var O = _toObject(arrayLike);
        var C = typeof this == "function" ? this : Array;
        var aLen = arguments.length;
        var mapfn = aLen > 1 ? arguments[1] : undefined;
        var mapping = mapfn !== undefined;
        var index = 0;
        var iterFn = core_getIteratorMethod(O);
        var length, result, step, iterator;
        if (mapping)
          mapfn = _ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2); // if object isn't iterable or it's array with default iterator - use simple case

        if (iterFn != undefined && !(C == Array && _isArrayIter(iterFn))) {
          for (
            iterator = iterFn.call(O), result = new C();
            !(step = iterator.next()).done;
            index++
          ) {
            _createProperty(
              result,
              index,
              mapping
                ? _iterCall(iterator, mapfn, [step.value, index], true)
                : step.value
            );
          }
        } else {
          length = _toLength(O.length);

          for (result = new C(length); length > index; index++) {
            _createProperty(
              result,
              index,
              mapping ? mapfn(O[index], index) : O[index]
            );
          }
        }

        result.length = index;
        return result;
      },
    }
  );

  var $at = _stringAt(true); // String.prototype[@@iterator]()

  _iterDefine(
    String,
    "String",
    function (iterated) {
      this._t = String(iterated); // target

      this._i = 0; // next index
      //
    },
    function () {
      var O = this._t;
      var index = this._i;
      var point;
      if (index >= O.length)
        return {
          value: undefined,
          done: true,
        };
      point = $at(O, index);
      this._i += point.length;
      return {
        value: point,
        done: false,
      };
    }
  );

  _export(
    _export.S +
      _export.F *
        _fails(function () {
          function F() {
            /* empty */
          }

          return !(Array.of.call(F) instanceof F);
        }),
    "Array",
    {
      //
      of: function /* ...args */
      of() {
        var index = 0;
        var aLen = arguments.length;
        var result = new (typeof this == "function" ? this : Array)(aLen);

        while (aLen > index) _createProperty(result, index, arguments[index++]);

        result.length = aLen;
        return result;
      },
    }
  );

  var $sort = [].sort;
  var test$1 = [1, 2, 3];
  _export(
    _export.P +
      _export.F *
        (_fails(function () {
          // IE8-
          test$1.sort(undefined);
        }) ||
          !_fails(function () {
            // V8 bug
            test$1.sort(null); // Old WebKit
          }) ||
          !_strictMethod($sort)),
    "Array",
    {
      // Array.prototype.sort(comparefn)
      sort: function sort(comparefn) {
        return comparefn === undefined
          ? $sort.call(_toObject(this))
          : $sort.call(_toObject(this), _aFunction(comparefn));
      },
    }
  );

  var $map = _arrayMethods(1);
  _export(_export.P + _export.F * !_strictMethod([].map, true), "Array", {
    //  Array.prototype.map(callbackfn [, thisArg])
    map: function map(
      callbackfn
      /* , thisArg */
    ) {
      return $map(this, callbackfn, arguments[1]);
    },
  });

  var $filter = _arrayMethods(2);
  _export(_export.P + _export.F * !_strictMethod([].filter, true), "Array", {
    //  Array.prototype.filter(callbackfn [, thisArg])
    filter: function filter(
      callbackfn
      /* , thisArg */
    ) {
      return $filter(this, callbackfn, arguments[1]);
    },
  });

  var $some = _arrayMethods(3);
  _export(_export.P + _export.F * !_strictMethod([].some, true), "Array", {
    //  Array.prototype.some(callbackfn [, thisArg])
    some: function some(
      callbackfn
      /* , thisArg */
    ) {
      return $some(this, callbackfn, arguments[1]);
    },
  });

  var $every = _arrayMethods(4);
  _export(_export.P + _export.F * !_strictMethod([].every, true), "Array", {
    //  Array.prototype.every(callbackfn [, thisArg])
    every: function every(
      callbackfn
      /* , thisArg */
    ) {
      return $every(this, callbackfn, arguments[1]);
    },
  });

  var _arrayReduce = function (that, callbackfn, aLen, memo, isRight) {
    _aFunction(callbackfn);
    var O = _toObject(that);
    var self = _iobject(O);
    var length = _toLength(O.length);
    var index = isRight ? length - 1 : 0;
    var i = isRight ? -1 : 1;
    if (aLen < 2)
      for (;;) {
        if (index in self) {
          memo = self[index];
          index += i;
          break;
        }

        index += i;

        if (isRight ? index < 0 : length <= index) {
          throw TypeError("Reduce of empty array with no initial value");
        }
      }

    for (; isRight ? index >= 0 : length > index; index += i)
      if (index in self) {
        memo = callbackfn(memo, self[index], index, O);
      }

    return memo;
  };

  _export(_export.P + _export.F * !_strictMethod([].reduce, true), "Array", {
    //  Array.prototype.reduce(callbackfn [, initialValue])
    reduce: function reduce(
      callbackfn
      /* , initialValue */
    ) {
      return _arrayReduce(
        this,
        callbackfn,
        arguments.length,
        arguments[1],
        false
      );
    },
  });

  _export(
    _export.P + _export.F * !_strictMethod([].reduceRight, true),
    "Array",
    {
      //  Array.prototype.reduceRight(callbackfn [, initialValue])
      reduceRight: function reduceRight(
        callbackfn
        /* , initialValue */
      ) {
        return _arrayReduce(
          this,
          callbackfn,
          arguments.length,
          arguments[1],
          true
        );
      },
    }
  );

  var $native$1 = [].lastIndexOf;
  var NEGATIVE_ZERO$1 = !!$native$1 && 1 / [1].lastIndexOf(1, -0) < 0;
  _export(
    _export.P + _export.F * (NEGATIVE_ZERO$1 || !_strictMethod($native$1)),
    "Array",
    {
      //  Array.prototype.lastIndexOf(searchElement [, fromIndex])
      lastIndexOf: function lastIndexOf(
        searchElement
        /* , fromIndex = @[*-1] */
      ) {
        // convert -0 to +0
        if (NEGATIVE_ZERO$1) return $native$1.apply(this, arguments) || 0;
        var O = _toIobject(this);
        var length = _toLength(O.length);
        var index = length - 1;
        if (arguments.length > 1)
          index = Math.min(index, _toInteger(arguments[1]));
        if (index < 0) index = length + index;

        for (; index >= 0; index--)
          if (index in O) if (O[index] === searchElement) return index || 0;

        return -1;
      },
    }
  );

  var _arrayCopyWithin =
    [].copyWithin ||
    function copyWithin(
      target,
      /* = 0 */
      start
      /* = 0, end = @length */
    ) {
      var O = _toObject(this);
      var len = _toLength(O.length);
      var to = _toAbsoluteIndex(target, len);
      var from = _toAbsoluteIndex(start, len);
      var end = arguments.length > 2 ? arguments[2] : undefined;
      var count = Math.min(
        (end === undefined ? len : _toAbsoluteIndex(end, len)) - from,
        len - to
      );
      var inc = 1;

      if (from < to && to < from + count) {
        inc = -1;
        from += count - 1;
        to += count - 1;
      }

      while (count-- > 0) {
        if (from in O) O[to] = O[from];
        else delete O[to];
        to += inc;
        from += inc;
      }

      return O;
    };

  _export(_export.P, "Array", {
    copyWithin: _arrayCopyWithin,
  });
  _addToUnscopables("copyWithin");

  var $find = _arrayMethods(5);
  var KEY = "find";
  var forced = true; // Shouldn't skip holes

  if (KEY in [])
    Array(1)[KEY](function () {
      forced = false;
    });
  _export(_export.P + _export.F * forced, "Array", {
    find: function find(
      callbackfn
      /* , that = undefined */
    ) {
      return $find(
        this,
        callbackfn,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });
  _addToUnscopables(KEY);

  var $find$1 = _arrayMethods(6);
  var KEY$1 = "findIndex";
  var forced$1 = true; // Shouldn't skip holes

  if (KEY$1 in [])
    Array(1)[KEY$1](function () {
      forced$1 = false;
    });
  _export(_export.P + _export.F * forced$1, "Array", {
    findIndex: function findIndex(
      callbackfn
      /* , that = undefined */
    ) {
      return $find$1(
        this,
        callbackfn,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });
  _addToUnscopables(KEY$1);

  var TYPED = _uid("typed_array");
  var VIEW = _uid("view");
  var ABV = !!(_global.ArrayBuffer && _global.DataView);
  var CONSTR = ABV;
  var i$2 = 0;
  var l = 9;
  var Typed;
  var TypedArrayConstructors =
    "Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array".split(
      ","
    );

  while (i$2 < l) {
    if ((Typed = _global[TypedArrayConstructors[i$2++]])) {
      _hide(Typed.prototype, TYPED, true);
      _hide(Typed.prototype, VIEW, true);
    } else CONSTR = false;
  }

  var _typed = {
    ABV: ABV,
    CONSTR: CONSTR,
    TYPED: TYPED,
    VIEW: VIEW,
  };

  var _redefineAll = function (target, src, safe) {
    for (var key in src) _redefine(target, key, src[key], safe);

    return target;
  };

  var _anInstance = function (it, Constructor, name, forbiddenField) {
    if (
      !(it instanceof Constructor) ||
      (forbiddenField !== undefined && forbiddenField in it)
    ) {
      throw TypeError(name + ": incorrect invocation!");
    }

    return it;
  };

  var _toIndex = function (it) {
    if (it === undefined) return 0;
    var number = _toInteger(it);
    var length = _toLength(number);
    if (number !== length) throw RangeError("Wrong length!");
    return length;
  };

  var _arrayFill = function fill(
    value
    /* , start = 0, end = @length */
  ) {
    var O = _toObject(this);
    var length = _toLength(O.length);
    var aLen = arguments.length;
    var index = _toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length);
    var end = aLen > 2 ? arguments[2] : undefined;
    var endPos = end === undefined ? length : _toAbsoluteIndex(end, length);

    while (endPos > index) O[index++] = value;

    return O;
  };

  var _typedBuffer = createCommonjsModule(function (module, exports) {
    var gOPN = _objectGopn.f;
    var dP = _objectDp.f;
    var ARRAY_BUFFER = "ArrayBuffer";
    var DATA_VIEW = "DataView";
    var PROTOTYPE = "prototype";
    var WRONG_LENGTH = "Wrong length!";
    var WRONG_INDEX = "Wrong index!";
    var $ArrayBuffer = _global[ARRAY_BUFFER];
    var $DataView = _global[DATA_VIEW];
    var Math = _global.Math;
    var RangeError = _global.RangeError; // eslint-disable-next-line no-shadow-restricted-names

    var Infinity = _global.Infinity;
    var BaseBuffer = $ArrayBuffer;
    var abs = Math.abs;
    var pow = Math.pow;
    var floor = Math.floor;
    var log = Math.log;
    var LN2 = Math.LN2;
    var BUFFER = "buffer";
    var BYTE_LENGTH = "byteLength";
    var BYTE_OFFSET = "byteOffset";
    var $BUFFER = _descriptors ? "_b" : BUFFER;
    var $LENGTH = _descriptors ? "_l" : BYTE_LENGTH;
    var $OFFSET = _descriptors ? "_o" : BYTE_OFFSET; // IEEE754 conversions based on

    function packIEEE754(value, mLen, nBytes) {
      var buffer = new Array(nBytes);
      var eLen = nBytes * 8 - mLen - 1;
      var eMax = (1 << eLen) - 1;
      var eBias = eMax >> 1;
      var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0;
      var i = 0;
      var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
      var e, m, c;
      value = abs(value); // eslint-disable-next-line no-self-compare

      if (value != value || value === Infinity) {
        // eslint-disable-next-line no-self-compare
        m = value != value ? 1 : 0;
        e = eMax;
      } else {
        e = floor(log(value) / LN2);

        if (value * (c = pow(2, -e)) < 1) {
          e--;
          c *= 2;
        }

        if (e + eBias >= 1) {
          value += rt / c;
        } else {
          value += rt * pow(2, 1 - eBias);
        }

        if (value * c >= 2) {
          e++;
          c /= 2;
        }

        if (e + eBias >= eMax) {
          m = 0;
          e = eMax;
        } else if (e + eBias >= 1) {
          m = (value * c - 1) * pow(2, mLen);
          e = e + eBias;
        } else {
          m = value * pow(2, eBias - 1) * pow(2, mLen);
          e = 0;
        }
      }

      for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8);

      e = (e << mLen) | m;
      eLen += mLen;

      for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8);

      buffer[--i] |= s * 128;
      return buffer;
    }

    function unpackIEEE754(buffer, mLen, nBytes) {
      var eLen = nBytes * 8 - mLen - 1;
      var eMax = (1 << eLen) - 1;
      var eBias = eMax >> 1;
      var nBits = eLen - 7;
      var i = nBytes - 1;
      var s = buffer[i--];
      var e = s & 127;
      var m;
      s >>= 7;

      for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8);

      m = e & ((1 << -nBits) - 1);
      e >>= -nBits;
      nBits += mLen;

      for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8);

      if (e === 0) {
        e = 1 - eBias;
      } else if (e === eMax) {
        return m ? NaN : s ? -Infinity : Infinity;
      } else {
        m = m + pow(2, mLen);
        e = e - eBias;
      }

      return (s ? -1 : 1) * m * pow(2, e - mLen);
    }

    function unpackI32(bytes) {
      return (bytes[3] << 24) | (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
    }

    function packI8(it) {
      return [it & 0xff];
    }

    function packI16(it) {
      return [it & 0xff, (it >> 8) & 0xff];
    }

    function packI32(it) {
      return [
        it & 0xff,
        (it >> 8) & 0xff,
        (it >> 16) & 0xff,
        (it >> 24) & 0xff,
      ];
    }

    function packF64(it) {
      return packIEEE754(it, 52, 8);
    }

    function packF32(it) {
      return packIEEE754(it, 23, 4);
    }

    function addGetter(C, key, internal) {
      dP(C[PROTOTYPE], key, {
        get: function () {
          return this[internal];
        },
      });
    }

    function get(view, bytes, index, isLittleEndian) {
      var numIndex = +index;
      var intIndex = _toIndex(numIndex);
      if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
      var store = view[$BUFFER]._b;
      var start = intIndex + view[$OFFSET];
      var pack = store.slice(start, start + bytes);
      return isLittleEndian ? pack : pack.reverse();
    }

    function set(view, bytes, index, conversion, value, isLittleEndian) {
      var numIndex = +index;
      var intIndex = _toIndex(numIndex);
      if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
      var store = view[$BUFFER]._b;
      var start = intIndex + view[$OFFSET];
      var pack = conversion(+value);

      for (var i = 0; i < bytes; i++)
        store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];
    }

    if (!_typed.ABV) {
      $ArrayBuffer = function ArrayBuffer(length) {
        _anInstance(this, $ArrayBuffer, ARRAY_BUFFER);
        var byteLength = _toIndex(length);
        this._b = _arrayFill.call(new Array(byteLength), 0);
        this[$LENGTH] = byteLength;
      };

      $DataView = function DataView(buffer, byteOffset, byteLength) {
        _anInstance(this, $DataView, DATA_VIEW);
        _anInstance(buffer, $ArrayBuffer, DATA_VIEW);
        var bufferLength = buffer[$LENGTH];
        var offset = _toInteger(byteOffset);
        if (offset < 0 || offset > bufferLength)
          throw RangeError("Wrong offset!");
        byteLength =
          byteLength === undefined
            ? bufferLength - offset
            : _toLength(byteLength);
        if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
        this[$BUFFER] = buffer;
        this[$OFFSET] = offset;
        this[$LENGTH] = byteLength;
      };

      if (_descriptors) {
        addGetter($ArrayBuffer, BYTE_LENGTH, "_l");
        addGetter($DataView, BUFFER, "_b");
        addGetter($DataView, BYTE_LENGTH, "_l");
        addGetter($DataView, BYTE_OFFSET, "_o");
      }

      _redefineAll($DataView[PROTOTYPE], {
        getInt8: function getInt8(byteOffset) {
          return (get(this, 1, byteOffset)[0] << 24) >> 24;
        },
        getUint8: function getUint8(byteOffset) {
          return get(this, 1, byteOffset)[0];
        },
        getInt16: function getInt16(
          byteOffset
          /* , littleEndian */
        ) {
          var bytes = get(this, 2, byteOffset, arguments[1]);
          return (((bytes[1] << 8) | bytes[0]) << 16) >> 16;
        },
        getUint16: function getUint16(
          byteOffset
          /* , littleEndian */
        ) {
          var bytes = get(this, 2, byteOffset, arguments[1]);
          return (bytes[1] << 8) | bytes[0];
        },
        getInt32: function getInt32(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackI32(get(this, 4, byteOffset, arguments[1]));
        },
        getUint32: function getUint32(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;
        },
        getFloat32: function getFloat32(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);
        },
        getFloat64: function getFloat64(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);
        },
        setInt8: function setInt8(byteOffset, value) {
          set(this, 1, byteOffset, packI8, value);
        },
        setUint8: function setUint8(byteOffset, value) {
          set(this, 1, byteOffset, packI8, value);
        },
        setInt16: function setInt16(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 2, byteOffset, packI16, value, arguments[2]);
        },
        setUint16: function setUint16(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 2, byteOffset, packI16, value, arguments[2]);
        },
        setInt32: function setInt32(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 4, byteOffset, packI32, value, arguments[2]);
        },
        setUint32: function setUint32(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 4, byteOffset, packI32, value, arguments[2]);
        },
        setFloat32: function setFloat32(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 4, byteOffset, packF32, value, arguments[2]);
        },
        setFloat64: function setFloat64(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 8, byteOffset, packF64, value, arguments[2]);
        },
      });
    } else {
      if (
        !_fails(function () {
          $ArrayBuffer(1);
        }) ||
        !_fails(function () {
          new $ArrayBuffer(-1); // eslint-disable-line no-new
        }) ||
        _fails(function () {
          new $ArrayBuffer(); // eslint-disable-line no-new

          new $ArrayBuffer(1.5); // eslint-disable-line no-new

          new $ArrayBuffer(NaN); // eslint-disable-line no-new

          return $ArrayBuffer.name != ARRAY_BUFFER;
        })
      ) {
        $ArrayBuffer = function ArrayBuffer(length) {
          _anInstance(this, $ArrayBuffer);
          return new BaseBuffer(_toIndex(length));
        };

        var ArrayBufferProto = ($ArrayBuffer[PROTOTYPE] =
          BaseBuffer[PROTOTYPE]);

        for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j; ) {
          if (!((key = keys[j++]) in $ArrayBuffer))
            _hide($ArrayBuffer, key, BaseBuffer[key]);
        }

        ArrayBufferProto.constructor = $ArrayBuffer;
      } // iOS Safari 7.x bug

      var view = new $DataView(new $ArrayBuffer(2));
      var $setInt8 = $DataView[PROTOTYPE].setInt8;
      view.setInt8(0, 2147483648);
      view.setInt8(1, 2147483649);
      if (view.getInt8(0) || !view.getInt8(1))
        _redefineAll(
          $DataView[PROTOTYPE],
          {
            setInt8: function setInt8(byteOffset, value) {
              $setInt8.call(this, byteOffset, (value << 24) >> 24);
            },
            setUint8: function setUint8(byteOffset, value) {
              $setInt8.call(this, byteOffset, (value << 24) >> 24);
            },
          },
          true
        );
    }

    _setToStringTag($ArrayBuffer, ARRAY_BUFFER);
    _setToStringTag($DataView, DATA_VIEW);
    _hide($DataView[PROTOTYPE], _typed.VIEW, true);
    exports[ARRAY_BUFFER] = $ArrayBuffer;
    exports[DATA_VIEW] = $DataView;
  });

  var _typedArray = createCommonjsModule(function (module) {
    if (_descriptors) {
      var LIBRARY = _library;
      var global = _global;
      var fails = _fails;
      var $export = _export;
      var $typed = _typed;
      var $buffer = _typedBuffer;
      var ctx = _ctx;
      var anInstance = _anInstance;
      var propertyDesc = _propertyDesc;
      var hide = _hide;
      var redefineAll = _redefineAll;
      var toInteger = _toInteger;
      var toLength = _toLength;
      var toIndex = _toIndex;
      var toAbsoluteIndex = _toAbsoluteIndex;
      var toPrimitive = _toPrimitive;
      var has = _has;
      var classof = _classof;
      var isObject = _isObject;
      var toObject = _toObject;
      var isArrayIter = _isArrayIter;
      var create = _objectCreate;
      var getPrototypeOf = _objectGpo;
      var gOPN = _objectGopn.f;
      var getIterFn = core_getIteratorMethod;
      var uid = _uid;
      var wks = _wks;
      var createArrayMethod = _arrayMethods;
      var createArrayIncludes = _arrayIncludes;
      var speciesConstructor = _speciesConstructor;
      var ArrayIterators = es6_array_iterator;
      var Iterators = _iterators;
      var $iterDetect = _iterDetect;
      var setSpecies = _setSpecies;
      var arrayFill = _arrayFill;
      var arrayCopyWithin = _arrayCopyWithin;
      var $DP = _objectDp;
      var $GOPD = _objectGopd;
      var dP = $DP.f;
      var gOPD = $GOPD.f;
      var RangeError = global.RangeError;
      var TypeError = global.TypeError;
      var Uint8Array = global.Uint8Array;
      var ARRAY_BUFFER = "ArrayBuffer";
      var SHARED_BUFFER = "Shared" + ARRAY_BUFFER;
      var BYTES_PER_ELEMENT = "BYTES_PER_ELEMENT";
      var PROTOTYPE = "prototype";
      var ArrayProto = Array[PROTOTYPE];
      var $ArrayBuffer = $buffer.ArrayBuffer;
      var $DataView = $buffer.DataView;
      var arrayForEach = createArrayMethod(0);
      var arrayFilter = createArrayMethod(2);
      var arraySome = createArrayMethod(3);
      var arrayEvery = createArrayMethod(4);
      var arrayFind = createArrayMethod(5);
      var arrayFindIndex = createArrayMethod(6);
      var arrayIncludes = createArrayIncludes(true);
      var arrayIndexOf = createArrayIncludes(false);
      var arrayValues = ArrayIterators.values;
      var arrayKeys = ArrayIterators.keys;
      var arrayEntries = ArrayIterators.entries;
      var arrayLastIndexOf = ArrayProto.lastIndexOf;
      var arrayReduce = ArrayProto.reduce;
      var arrayReduceRight = ArrayProto.reduceRight;
      var arrayJoin = ArrayProto.join;
      var arraySort = ArrayProto.sort;
      var arraySlice = ArrayProto.slice;
      var arrayToString = ArrayProto.toString;
      var arrayToLocaleString = ArrayProto.toLocaleString;
      var ITERATOR = wks("iterator");
      var TAG = wks("toStringTag");
      var TYPED_CONSTRUCTOR = uid("typed_constructor");
      var DEF_CONSTRUCTOR = uid("def_constructor");
      var ALL_CONSTRUCTORS = $typed.CONSTR;
      var TYPED_ARRAY = $typed.TYPED;
      var VIEW = $typed.VIEW;
      var WRONG_LENGTH = "Wrong length!";
      var $map = createArrayMethod(1, function (O, length) {
        return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
      });
      var LITTLE_ENDIAN = fails(function () {
        // eslint-disable-next-line no-undef
        return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
      });
      var FORCED_SET =
        !!Uint8Array &&
        !!Uint8Array[PROTOTYPE].set &&
        fails(function () {
          new Uint8Array(1).set({});
        });

      var toOffset = function (it, BYTES) {
        var offset = toInteger(it);
        if (offset < 0 || offset % BYTES) throw RangeError("Wrong offset!");
        return offset;
      };

      var validate = function (it) {
        if (isObject(it) && TYPED_ARRAY in it) return it;
        throw TypeError(it + " is not a typed array!");
      };

      var allocate = function (C, length) {
        if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {
          throw TypeError("It is not a typed array constructor!");
        }

        return new C(length);
      };

      var speciesFromList = function (O, list) {
        return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
      };

      var fromList = function (C, list) {
        var index = 0;
        var length = list.length;
        var result = allocate(C, length);

        while (length > index) result[index] = list[index++];

        return result;
      };

      var addGetter = function (it, key, internal) {
        dP(it, key, {
          get: function () {
            return this._d[internal];
          },
        });
      };

      var $from = function from(
        source
        /* , mapfn, thisArg */
      ) {
        var O = toObject(source);
        var aLen = arguments.length;
        var mapfn = aLen > 1 ? arguments[1] : undefined;
        var mapping = mapfn !== undefined;
        var iterFn = getIterFn(O);
        var i, length, values, result, step, iterator;

        if (iterFn != undefined && !isArrayIter(iterFn)) {
          for (
            iterator = iterFn.call(O), values = [], i = 0;
            !(step = iterator.next()).done;
            i++
          ) {
            values.push(step.value);
          }

          O = values;
        }

        if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);

        for (
          i = 0, length = toLength(O.length), result = allocate(this, length);
          length > i;
          i++
        ) {
          result[i] = mapping ? mapfn(O[i], i) : O[i];
        }

        return result;
      };

      var $of = function /* ...items */
      of() {
        var index = 0;
        var length = arguments.length;
        var result = allocate(this, length);

        while (length > index) result[index] = arguments[index++];

        return result;
      }; // iOS Safari 6.x fails here

      var TO_LOCALE_BUG =
        !!Uint8Array &&
        fails(function () {
          arrayToLocaleString.call(new Uint8Array(1));
        });

      var $toLocaleString = function toLocaleString() {
        return arrayToLocaleString.apply(
          TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this),
          arguments
        );
      };

      var proto = {
        copyWithin: function copyWithin(
          target,
          start
          /* , end */
        ) {
          return arrayCopyWithin.call(
            validate(this),
            target,
            start,
            arguments.length > 2 ? arguments[2] : undefined
          );
        },
        every: function every(
          callbackfn
          /* , thisArg */
        ) {
          return arrayEvery(
            validate(this),
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        fill: function fill(
          value
          /* , start, end */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayFill.apply(validate(this), arguments);
        },
        filter: function filter(
          callbackfn
          /* , thisArg */
        ) {
          return speciesFromList(
            this,
            arrayFilter(
              validate(this),
              callbackfn,
              arguments.length > 1 ? arguments[1] : undefined
            )
          );
        },
        find: function find(
          predicate
          /* , thisArg */
        ) {
          return arrayFind(
            validate(this),
            predicate,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        findIndex: function findIndex(
          predicate
          /* , thisArg */
        ) {
          return arrayFindIndex(
            validate(this),
            predicate,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        forEach: function forEach(
          callbackfn
          /* , thisArg */
        ) {
          arrayForEach(
            validate(this),
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        indexOf: function indexOf(
          searchElement
          /* , fromIndex */
        ) {
          return arrayIndexOf(
            validate(this),
            searchElement,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        includes: function includes(
          searchElement
          /* , fromIndex */
        ) {
          return arrayIncludes(
            validate(this),
            searchElement,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        join: function join(separator) {
          // eslint-disable-line no-unused-vars
          return arrayJoin.apply(validate(this), arguments);
        },
        lastIndexOf: function lastIndexOf(
          searchElement
          /* , fromIndex */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayLastIndexOf.apply(validate(this), arguments);
        },
        map: function map(
          mapfn
          /* , thisArg */
        ) {
          return $map(
            validate(this),
            mapfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        reduce: function reduce(
          callbackfn
          /* , initialValue */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayReduce.apply(validate(this), arguments);
        },
        reduceRight: function reduceRight(
          callbackfn
          /* , initialValue */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayReduceRight.apply(validate(this), arguments);
        },
        reverse: function reverse() {
          var that = this;
          var length = validate(that).length;
          var middle = Math.floor(length / 2);
          var index = 0;
          var value;

          while (index < middle) {
            value = that[index];
            that[index++] = that[--length];
            that[length] = value;
          }

          return that;
        },
        some: function some(
          callbackfn
          /* , thisArg */
        ) {
          return arraySome(
            validate(this),
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        sort: function sort(comparefn) {
          return arraySort.call(validate(this), comparefn);
        },
        subarray: function subarray(begin, end) {
          var O = validate(this);
          var length = O.length;
          var $begin = toAbsoluteIndex(begin, length);
          return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
            O.buffer,
            O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
            toLength(
              (end === undefined ? length : toAbsoluteIndex(end, length)) -
                $begin
            )
          );
        },
      };

      var $slice = function slice(start, end) {
        return speciesFromList(
          this,
          arraySlice.call(validate(this), start, end)
        );
      };

      var $set = function set(
        arrayLike
        /* , offset */
      ) {
        validate(this);
        var offset = toOffset(arguments[1], 1);
        var length = this.length;
        var src = toObject(arrayLike);
        var len = toLength(src.length);
        var index = 0;
        if (len + offset > length) throw RangeError(WRONG_LENGTH);

        while (index < len) this[offset + index] = src[index++];
      };

      var $iterators = {
        entries: function entries() {
          return arrayEntries.call(validate(this));
        },
        keys: function keys() {
          return arrayKeys.call(validate(this));
        },
        values: function values() {
          return arrayValues.call(validate(this));
        },
      };

      var isTAIndex = function (target, key) {
        return (
          isObject(target) &&
          target[TYPED_ARRAY] &&
          typeof key != "symbol" &&
          key in target &&
          String(+key) == String(key)
        );
      };

      var $getDesc = function getOwnPropertyDescriptor(target, key) {
        return isTAIndex(target, (key = toPrimitive(key, true)))
          ? propertyDesc(2, target[key])
          : gOPD(target, key);
      };

      var $setDesc = function defineProperty(target, key, desc) {
        if (
          isTAIndex(target, (key = toPrimitive(key, true))) &&
          isObject(desc) &&
          has(desc, "value") &&
          !has(desc, "get") &&
          !has(desc, "set") && // TODO: add validation descriptor w/o calling accessors
          !desc.configurable &&
          (!has(desc, "writable") || desc.writable) &&
          (!has(desc, "enumerable") || desc.enumerable)
        ) {
          target[key] = desc.value;
          return target;
        }

        return dP(target, key, desc);
      };

      if (!ALL_CONSTRUCTORS) {
        $GOPD.f = $getDesc;
        $DP.f = $setDesc;
      }

      $export($export.S + $export.F * !ALL_CONSTRUCTORS, "Object", {
        getOwnPropertyDescriptor: $getDesc,
        defineProperty: $setDesc,
      });

      if (
        fails(function () {
          arrayToString.call({});
        })
      ) {
        arrayToString = arrayToLocaleString = function toString() {
          return arrayJoin.call(this);
        };
      }

      var $TypedArrayPrototype$ = redefineAll({}, proto);
      redefineAll($TypedArrayPrototype$, $iterators);
      hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
      redefineAll($TypedArrayPrototype$, {
        slice: $slice,
        set: $set,
        constructor: function () {
          /* noop */
        },
        toString: arrayToString,
        toLocaleString: $toLocaleString,
      });
      addGetter($TypedArrayPrototype$, "buffer", "b");
      addGetter($TypedArrayPrototype$, "byteOffset", "o");
      addGetter($TypedArrayPrototype$, "byteLength", "l");
      addGetter($TypedArrayPrototype$, "length", "e");
      dP($TypedArrayPrototype$, TAG, {
        get: function () {
          return this[TYPED_ARRAY];
        },
      }); // eslint-disable-next-line max-statements

      module.exports = function (KEY, BYTES, wrapper, CLAMPED) {
        CLAMPED = !!CLAMPED;
        var NAME = KEY + (CLAMPED ? "Clamped" : "") + "Array";
        var GETTER = "get" + KEY;
        var SETTER = "set" + KEY;
        var TypedArray = global[NAME];
        var Base = TypedArray || {};
        var TAC = TypedArray && getPrototypeOf(TypedArray);
        var FORCED = !TypedArray || !$typed.ABV;
        var O = {};
        var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];

        var getter = function (that, index) {
          var data = that._d;
          return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
        };

        var setter = function (that, index, value) {
          var data = that._d;
          if (CLAMPED)
            value =
              (value = Math.round(value)) < 0
                ? 0
                : value > 0xff
                ? 0xff
                : value & 0xff;
          data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
        };

        var addElement = function (that, index) {
          dP(that, index, {
            get: function () {
              return getter(this, index);
            },
            set: function (value) {
              return setter(this, index, value);
            },
            enumerable: true,
          });
        };

        if (FORCED) {
          TypedArray = wrapper(function (that, data, $offset, $length) {
            anInstance(that, TypedArray, NAME, "_d");
            var index = 0;
            var offset = 0;
            var buffer, byteLength, length, klass;

            if (!isObject(data)) {
              length = toIndex(data);
              byteLength = length * BYTES;
              buffer = new $ArrayBuffer(byteLength);
            } else if (
              data instanceof $ArrayBuffer ||
              (klass = classof(data)) == ARRAY_BUFFER ||
              klass == SHARED_BUFFER
            ) {
              buffer = data;
              offset = toOffset($offset, BYTES);
              var $len = data.byteLength;

              if ($length === undefined) {
                if ($len % BYTES) throw RangeError(WRONG_LENGTH);
                byteLength = $len - offset;
                if (byteLength < 0) throw RangeError(WRONG_LENGTH);
              } else {
                byteLength = toLength($length) * BYTES;
                if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);
              }

              length = byteLength / BYTES;
            } else if (TYPED_ARRAY in data) {
              return fromList(TypedArray, data);
            } else {
              return $from.call(TypedArray, data);
            }

            hide(that, "_d", {
              b: buffer,
              o: offset,
              l: byteLength,
              e: length,
              v: new $DataView(buffer),
            });

            while (index < length) addElement(that, index++);
          });
          TypedArrayPrototype = TypedArray[PROTOTYPE] = create(
            $TypedArrayPrototype$
          );
          hide(TypedArrayPrototype, "constructor", TypedArray);
        } else if (
          !fails(function () {
            TypedArray(1);
          }) ||
          !fails(function () {
            new TypedArray(-1); // eslint-disable-line no-new
          }) ||
          !$iterDetect(function (iter) {
            new TypedArray(); // eslint-disable-line no-new

            new TypedArray(null); // eslint-disable-line no-new

            new TypedArray(1.5); // eslint-disable-line no-new

            new TypedArray(iter); // eslint-disable-line no-new
          }, true)
        ) {
          TypedArray = wrapper(function (that, data, $offset, $length) {
            anInstance(that, TypedArray, NAME);
            var klass; // `ws` module bug, temporarily remove validation length for Uint8Array


            if (!isObject(data)) return new Base(toIndex(data));

            if (
              data instanceof $ArrayBuffer ||
              (klass = classof(data)) == ARRAY_BUFFER ||
              klass == SHARED_BUFFER
            ) {
              return $length !== undefined
                ? new Base(data, toOffset($offset, BYTES), $length)
                : $offset !== undefined
                ? new Base(data, toOffset($offset, BYTES))
                : new Base(data);
            }

            if (TYPED_ARRAY in data) return fromList(TypedArray, data);
            return $from.call(TypedArray, data);
          });
          arrayForEach(
            TAC !== Function.prototype
              ? gOPN(Base).concat(gOPN(TAC))
              : gOPN(Base),
            function (key) {
              if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);
            }
          );
          TypedArray[PROTOTYPE] = TypedArrayPrototype;
          if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;
        }

        var $nativeIterator = TypedArrayPrototype[ITERATOR];
        var CORRECT_ITER_NAME =
          !!$nativeIterator &&
          ($nativeIterator.name == "values" ||
            $nativeIterator.name == undefined);
        var $iterator = $iterators.values;
        hide(TypedArray, TYPED_CONSTRUCTOR, true);
        hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
        hide(TypedArrayPrototype, VIEW, true);
        hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);

        if (
          CLAMPED
            ? new TypedArray(1)[TAG] != NAME
            : !(TAG in TypedArrayPrototype)
        ) {
          dP(TypedArrayPrototype, TAG, {
            get: function () {
              return NAME;
            },
          });
        }

        O[NAME] = TypedArray;
        $export($export.G + $export.W + $export.F * (TypedArray != Base), O);
        $export($export.S, NAME, {
          BYTES_PER_ELEMENT: BYTES,
        });
        $export(
          $export.S +
            $export.F *
              fails(function () {
                Base.of.call(TypedArray, 1);
              }),
          NAME,
          {
            from: $from,
            of: $of,
          }
        );
        if (!(BYTES_PER_ELEMENT in TypedArrayPrototype))
          hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);
        $export($export.P, NAME, proto);
        setSpecies(NAME);
        $export($export.P + $export.F * FORCED_SET, NAME, {
          set: $set,
        });
        $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);
        if (!LIBRARY && TypedArrayPrototype.toString != arrayToString)
          TypedArrayPrototype.toString = arrayToString;
        $export(
          $export.P +
            $export.F *
              fails(function () {
                new TypedArray(1).slice();
              }),
          NAME,
          {
            slice: $slice,
          }
        );
        $export(
          $export.P +
            $export.F *
              (fails(function () {
                return (
                  [1, 2].toLocaleString() !=
                  new TypedArray([1, 2]).toLocaleString()
                );
              }) ||
                !fails(function () {
                  TypedArrayPrototype.toLocaleString.call([1, 2]);
                })),
          NAME,
          {
            toLocaleString: $toLocaleString,
          }
        );
        Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
        if (!LIBRARY && !CORRECT_ITER_NAME)
          hide(TypedArrayPrototype, ITERATOR, $iterator);
      };
    } else
      module.exports = function () {
        /* empty */
      };
  });

  _typedArray("Uint16", 2, function (init) {
    return function Uint16Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  // MS Edge has broken Reflect.defineProperty - throwing instead of returning false

  _export(
    _export.S +
      _export.F *
        _fails(function () {
          // eslint-disable-next-line no-undef
          Reflect.defineProperty(
            _objectDp.f({}, 1, {
              value: 1,
            }),
            1,
            {
              value: 2,
            }
          );
        }),
    "Reflect",
    {
      defineProperty: function defineProperty(target, propertyKey, attributes) {
        _anObject(target);
        propertyKey = _toPrimitive(propertyKey, true);
        _anObject(attributes);

        try {
          _objectDp.f(target, propertyKey, attributes);
          return true;
        } catch (e) {
          return false;
        }
      },
    }
  );

  var INCLUDES = "includes";
  _export(_export.P + _export.F * _failsIsRegexp(INCLUDES), "String", {
    includes: function includes(
      searchString
      /* , position = 0 */
    ) {
      return !!~_stringContext(this, searchString, INCLUDES).indexOf(
        searchString,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });

  var $includes = _arrayIncludes(true);
  _export(_export.P, "Array", {
    includes: function includes(
      el
      /* , fromIndex = 0 */
    ) {
      return $includes(
        this,
        el,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });
  _addToUnscopables("includes");

  var IS_CONCAT_SPREADABLE = _wks("isConcatSpreadable");

  function flattenIntoArray(
    target,
    original,
    source,
    sourceLen,
    start,
    depth,
    mapper,
    thisArg
  ) {
    var targetIndex = start;
    var sourceIndex = 0;
    var mapFn = mapper ? _ctx(mapper, thisArg, 3) : false;
    var element, spreadable;

    while (sourceIndex < sourceLen) {
      if (sourceIndex in source) {
        element = mapFn
          ? mapFn(source[sourceIndex], sourceIndex, original)
          : source[sourceIndex];
        spreadable = false;

        if (_isObject(element)) {
          spreadable = element[IS_CONCAT_SPREADABLE];
          spreadable =
            spreadable !== undefined ? !!spreadable : _isArray(element);
        }

        if (spreadable && depth > 0) {
          targetIndex =
            flattenIntoArray(
              target,
              original,
              element,
              _toLength(element.length),
              targetIndex,
              depth - 1
            ) - 1;
        } else {
          if (targetIndex >= 0x1fffffffffffff) throw TypeError();
          target[targetIndex] = element;
        }

        targetIndex++;
      }

      sourceIndex++;
    }

    return targetIndex;
  }

  var _flattenIntoArray = flattenIntoArray;

  _export(_export.P, "Array", {
    flatMap: function flatMap(
      callbackfn
      /* , thisArg */
    ) {
      var O = _toObject(this);
      var sourceLen, A;
      _aFunction(callbackfn);
      sourceLen = _toLength(O.length);
      A = _arraySpeciesCreate(O, 0);
      _flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]);
      return A;
    },
  });
  _addToUnscopables("flatMap");

  var _stringRepeat = function repeat(count) {
    var str = String(_defined(this));
    var res = "";
    var n = _toInteger(count);
    if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");

    for (; n > 0; (n >>>= 1) && (str += str)) if (n & 1) res += str;

    return res;
  };

  var _stringPad = function (that, maxLength, fillString, left) {
    var S = String(_defined(that));
    var stringLength = S.length;
    var fillStr = fillString === undefined ? " " : String(fillString);
    var intMaxLength = _toLength(maxLength);
    if (intMaxLength <= stringLength || fillStr == "") return S;
    var fillLen = intMaxLength - stringLength;
    var stringFiller = _stringRepeat.call(
      fillStr,
      Math.ceil(fillLen / fillStr.length)
    );
    if (stringFiller.length > fillLen)
      stringFiller = stringFiller.slice(0, fillLen);
    return left ? stringFiller + S : S + stringFiller;
  };

  var navigator = _global.navigator;

  var _userAgent = (navigator && navigator.userAgent) || "";



  var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(
    _userAgent
  );
  _export(_export.P + _export.F * WEBKIT_BUG, "String", {
    padStart: function padStart(
      maxLength
      /* , fillString = ' ' */
    ) {
      return _stringPad(
        this,
        maxLength,
        arguments.length > 1 ? arguments[1] : undefined,
        true
      );
    },
  });


  var WEBKIT_BUG$1 = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(
    _userAgent
  );
  _export(_export.P + _export.F * WEBKIT_BUG$1, "String", {
    padEnd: function padEnd(
      maxLength
      /* , fillString = ' ' */
    ) {
      return _stringPad(
        this,
        maxLength,
        arguments.length > 1 ? arguments[1] : undefined,
        false
      );
    },
  });

  _stringTrim(
    "trimLeft",
    function ($trim) {
      return function trimLeft() {
        return $trim(this, 1);
      };
    },
    "trimStart"
  );

  _stringTrim(
    "trimRight",
    function ($trim) {
      return function trimRight() {
        return $trim(this, 2);
      };
    },
    "trimEnd"
  );

  function PromiseCapability(C) {
    var resolve, reject;
    this.promise = new C(function ($$resolve, $$reject) {
      if (resolve !== undefined || reject !== undefined)
        throw TypeError("Bad Promise constructor");
      resolve = $$resolve;
      reject = $$reject;
    });
    this.resolve = _aFunction(resolve);
    this.reject = _aFunction(reject);
  }

  var f$7 = function (C) {
    return new PromiseCapability(C);
  };

  var _newPromiseCapability = {
    f: f$7,
  };

  var _promiseResolve = function (C, x) {
    _anObject(C);
    if (_isObject(x) && x.constructor === C) return x;
    var promiseCapability = _newPromiseCapability.f(C);
    var resolve = promiseCapability.resolve;
    resolve(x);
    return promiseCapability.promise;
  };

  _export(_export.P + _export.R, "Promise", {
    finally: function (onFinally) {
      var C = _speciesConstructor(this, _core.Promise || _global.Promise);
      var isFunction = typeof onFinally == "function";
      return this.then(
        isFunction
          ? function (x) {
              return _promiseResolve(C, onFinally()).then(function () {
                return x;
              });
            }
          : onFinally,
        isFunction
          ? function (e) {
              return _promiseResolve(C, onFinally()).then(function () {
                throw e;
              });
            }
          : onFinally
      );
    },
  });

  var _forOf = createCommonjsModule(function (module) {
    var BREAK = {};
    var RETURN = {};

    var exports = (module.exports = function (
      iterable,
      entries,
      fn,
      that,
      ITERATOR
    ) {
      var iterFn = ITERATOR
        ? function () {
            return iterable;
          }
        : core_getIteratorMethod(iterable);
      var f = _ctx(fn, that, entries ? 2 : 1);
      var index = 0;
      var length, step, iterator, result;
      if (typeof iterFn != "function")
        throw TypeError(iterable + " is not iterable!"); // fast case for arrays with default iterator

      if (_isArrayIter(iterFn))
        for (length = _toLength(iterable.length); length > index; index++) {
          result = entries
            ? f(_anObject((step = iterable[index]))[0], step[1])
            : f(iterable[index]);
          if (result === BREAK || result === RETURN) return result;
        }
      else
        for (
          iterator = iterFn.call(iterable);
          !(step = iterator.next()).done;

        ) {
          result = _iterCall(iterator, f, step.value, entries);
          if (result === BREAK || result === RETURN) return result;
        }
    });

    exports.BREAK = BREAK;
    exports.RETURN = RETURN;
  });

  var process = _global.process;
  var setTask = _global.setImmediate;
  var clearTask = _global.clearImmediate;
  var MessageChannel = _global.MessageChannel;
  var Dispatch = _global.Dispatch;
  var counter = 0;
  var queue = {};
  var ONREADYSTATECHANGE = "onreadystatechange";
  var defer, channel, port;

  var run = function () {
    var id = +this; // eslint-disable-next-line no-prototype-builtins

    if (queue.hasOwnProperty(id)) {
      var fn = queue[id];
      delete queue[id];
      fn();
    }
  };

  var listener = function (event) {
    run.call(event.data);
  }; // Node.js 0.9+ & IE10+ has setImmediate, otherwise:

  if (!setTask || !clearTask) {
    setTask = function setImmediate(fn) {
      var args = [];
      var i = 1;

      while (arguments.length > i) args.push(arguments[i++]);

      queue[++counter] = function () {
        // eslint-disable-next-line no-new-func
        _invoke(typeof fn == "function" ? fn : Function(fn), args);
      };

      defer(counter);
      return counter;
    };

    clearTask = function clearImmediate(id) {
      delete queue[id];
    }; // Node.js 0.8-

    if (_cof(process) == "process") {
      defer = function (id) {
        process.nextTick(_ctx(run, id, 1));
      }; // Sphere (JS game engine) Dispatch API
    } else if (Dispatch && Dispatch.now) {
      defer = function (id) {
        Dispatch.now(_ctx(run, id, 1));
      }; // Browsers with MessageChannel, includes WebWorkers
    } else if (MessageChannel) {
      channel = new MessageChannel();
      port = channel.port2;
      channel.port1.onmessage = listener;
      defer = _ctx(port.postMessage, port, 1); // Browsers with postMessage, skip WebWorkers
      // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
    } else if (
      _global.addEventListener &&
      typeof postMessage == "function" &&
      !_global.importScripts
    ) {
      defer = function (id) {
        _global.postMessage(id + "", "*");
      };

      _global.addEventListener("message", listener, false); // IE8-
    } else if (ONREADYSTATECHANGE in _domCreate("script")) {
      defer = function (id) {
        _html.appendChild(_domCreate("script"))[ONREADYSTATECHANGE] =
          function () {
            _html.removeChild(this);
            run.call(id);
          };
      }; // Rest old browsers
    } else {
      defer = function (id) {
        setTimeout(_ctx(run, id, 1), 0);
      };
    }
  }

  var _task = {
    set: setTask,
    clear: clearTask,
  };

  var macrotask = _task.set;
  var Observer = _global.MutationObserver || _global.WebKitMutationObserver;
  var process$1 = _global.process;
  var Promise$1 = _global.Promise;
  var isNode = _cof(process$1) == "process";

  var _microtask = function () {
    var head, last, notify;

    var flush = function () {
      var parent, fn;
      if (isNode && (parent = process$1.domain)) parent.exit();

      while (head) {
        fn = head.fn;
        head = head.next;

        try {
          fn();
        } catch (e) {
          if (head) notify();
          else last = undefined;
          throw e;
        }
      }

      last = undefined;
      if (parent) parent.enter();
    }; // Node.js

    if (isNode) {
      notify = function () {
        process$1.nextTick(flush);
      }; // browsers with MutationObserver, except iOS Safari
    } else if (
      Observer &&
      !(_global.navigator && _global.navigator.standalone)
    ) {
      var toggle = true;
      var node = document.createTextNode("");
      new Observer(flush).observe(node, {
        characterData: true,
      }); // eslint-disable-line no-new

      notify = function () {
        node.data = toggle = !toggle;
      }; // environments with maybe non-completely correct, but existent Promise
    } else if (Promise$1 && Promise$1.resolve) {
      // Promise.resolve without an argument throws an error in LG WebOS 2
      var promise = Promise$1.resolve(undefined);

      notify = function () {
        promise.then(flush);
      }; // for other environments - macrotask based on:
      // - setImmediate
      // - MessageChannel
      // - window.postMessag
      // - onreadystatechange
      // - setTimeout
    } else {
      notify = function () {
        // strange IE + webpack dev server bug - use .call(global)
        macrotask.call(_global, flush);
      };
    }

    return function (fn) {
      var task = {
        fn: fn,
        next: undefined,
      };
      if (last) last.next = task;

      if (!head) {
        head = task;
        notify();
      }

      last = task;
    };
  };

  var _perform = function (exec) {
    try {
      return {
        e: false,
        v: exec(),
      };
    } catch (e) {
      return {
        e: true,
        v: e,
      };
    }
  };

  var task = _task.set;
  var microtask = _microtask();
  var PROMISE = "Promise";
  var TypeError$1 = _global.TypeError;
  var process$2 = _global.process;
  var versions = process$2 && process$2.versions;
  var v8 = (versions && versions.v8) || "";
  var $Promise = _global[PROMISE];
  var isNode$1 = _classof(process$2) == "process";

  var empty = function () {
    /* empty */
  };

  var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
  var newPromiseCapability = (newGenericPromiseCapability =
    _newPromiseCapability.f);
  var USE_NATIVE$1 = !!(function () {
    try {
      // correct subclassing with @@species support
      var promise = $Promise.resolve(1);

      var FakePromise = ((promise.constructor = {})[_wks("species")] =
        function (exec) {
          exec(empty, empty);
        }); // unhandled rejections tracking support, NodeJS Promise without it fails @@species test

      return (
        (isNode$1 || typeof PromiseRejectionEvent == "function") &&
        promise.then(empty) instanceof FakePromise && // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
        // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
        // we can't detect it synchronously, so just check versions
        v8.indexOf("6.6") !== 0 &&
        _userAgent.indexOf("Chrome/66") === -1
      );
    } catch (e) {
      /* empty */
    }
  })(); // helpers

  var isThenable = function (it) {
    var then;
    return _isObject(it) && typeof (then = it.then) == "function"
      ? then
      : false;
  };

  var notify = function (promise, isReject) {
    if (promise._n) return;
    promise._n = true;
    var chain = promise._c;
    microtask(function () {
      var value = promise._v;
      var ok = promise._s == 1;
      var i = 0;

      var run = function (reaction) {
        var handler = ok ? reaction.ok : reaction.fail;
        var resolve = reaction.resolve;
        var reject = reaction.reject;
        var domain = reaction.domain;
        var result, then, exited;

        try {
          if (handler) {
            if (!ok) {
              if (promise._h == 2) onHandleUnhandled(promise);
              promise._h = 1;
            }

            if (handler === true) result = value;
            else {
              if (domain) domain.enter();
              result = handler(value); // may throw

              if (domain) {
                domain.exit();
                exited = true;
              }
            }

            if (result === reaction.promise) {
              reject(TypeError$1("Promise-chain cycle"));
            } else if ((then = isThenable(result))) {
              then.call(result, resolve, reject);
            } else resolve(result);
          } else reject(value);
        } catch (e) {
          if (domain && !exited) domain.exit();
          reject(e);
        }
      };

      while (chain.length > i) run(chain[i++]); // variable length - can't use forEach

      promise._c = [];
      promise._n = false;
      if (isReject && !promise._h) onUnhandled(promise);
    });
  };

  var onUnhandled = function (promise) {
    task.call(_global, function () {
      var value = promise._v;
      var unhandled = isUnhandled(promise);
      var result, handler, console;

      if (unhandled) {
        result = _perform(function () {
          if (isNode$1) {
            process$2.emit("unhandledRejection", value, promise);
          } else if ((handler = _global.onunhandledrejection)) {
            handler({
              promise: promise,
              reason: value,
            });
          } else if ((console = _global.console) && console.error) {
            console.error("Unhandled promise rejection", value);
          }
        }); // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should

        promise._h = isNode$1 || isUnhandled(promise) ? 2 : 1;
      }

      promise._a = undefined;
      if (unhandled && result.e) throw result.v;
    });
  };

  var isUnhandled = function (promise) {
    return promise._h !== 1 && (promise._a || promise._c).length === 0;
  };

  var onHandleUnhandled = function (promise) {
    task.call(_global, function () {
      var handler;

      if (isNode$1) {
        process$2.emit("rejectionHandled", promise);
      } else if ((handler = _global.onrejectionhandled)) {
        handler({
          promise: promise,
          reason: promise._v,
        });
      }
    });
  };

  var $reject = function (value) {
    var promise = this;
    if (promise._d) return;
    promise._d = true;
    promise = promise._w || promise; // unwrap

    promise._v = value;
    promise._s = 2;
    if (!promise._a) promise._a = promise._c.slice();
    notify(promise, true);
  };

  var $resolve = function (value) {
    var promise = this;
    var then;
    if (promise._d) return;
    promise._d = true;
    promise = promise._w || promise; // unwrap

    try {
      if (promise === value)
        throw TypeError$1("Promise can't be resolved itself");

      if ((then = isThenable(value))) {
        microtask(function () {
          var wrapper = {
            _w: promise,
            _d: false,
          }; // wrap

          try {
            then.call(
              value,
              _ctx($resolve, wrapper, 1),
              _ctx($reject, wrapper, 1)
            );
          } catch (e) {
            $reject.call(wrapper, e);
          }
        });
      } else {
        promise._v = value;
        promise._s = 1;
        notify(promise, false);
      }
    } catch (e) {
      $reject.call(
        {
          _w: promise,
          _d: false,
        },
        e
      ); // wrap
    }
  }; // constructor polyfill

  if (!USE_NATIVE$1) {

    $Promise = function Promise(executor) {
      _anInstance(this, $Promise, PROMISE, "_h");
      _aFunction(executor);
      Internal.call(this);

      try {
        executor(_ctx($resolve, this, 1), _ctx($reject, this, 1));
      } catch (err) {
        $reject.call(this, err);
      }
    }; // eslint-disable-next-line no-unused-vars

    Internal = function Promise(executor) {
      this._c = []; // <- awaiting reactions

      this._a = undefined; // <- checked in isUnhandled reactions

      this._s = 0; // <- state

      this._d = false; // <- done

      this._v = undefined; // <- value

      this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled

      this._n = false; // <- notify
    };

    Internal.prototype = _redefineAll($Promise.prototype, {
      // Promise.prototype.then(onFulfilled, onRejected)
      then: function then(onFulfilled, onRejected) {
        var reaction = newPromiseCapability(
          _speciesConstructor(this, $Promise)
        );
        reaction.ok = typeof onFulfilled == "function" ? onFulfilled : true;
        reaction.fail = typeof onRejected == "function" && onRejected;
        reaction.domain = isNode$1 ? process$2.domain : undefined;

        this._c.push(reaction);

        if (this._a) this._a.push(reaction);
        if (this._s) notify(this, false);
        return reaction.promise;
      },
      // Promise.prototype.catch(onRejected)
      catch: function (onRejected) {
        return this.then(undefined, onRejected);
      },
    });

    OwnPromiseCapability = function () {
      var promise = new Internal();
      this.promise = promise;
      this.resolve = _ctx($resolve, promise, 1);
      this.reject = _ctx($reject, promise, 1);
    };

    _newPromiseCapability.f = newPromiseCapability = function (C) {
      return C === $Promise || C === Wrapper
        ? new OwnPromiseCapability(C)
        : newGenericPromiseCapability(C);
    };
  }

  _export(_export.G + _export.W + _export.F * !USE_NATIVE$1, {
    Promise: $Promise,
  });
  _setToStringTag($Promise, PROMISE);
  _setSpecies(PROMISE);
  Wrapper = _core[PROMISE]; // statics

  _export(_export.S + _export.F * !USE_NATIVE$1, PROMISE, {
    //  Promise.reject(r)
    reject: function reject(r) {
      var capability = newPromiseCapability(this);
      var $$reject = capability.reject;
      $$reject(r);
      return capability.promise;
    },
  });
  _export(_export.S + _export.F * !USE_NATIVE$1, PROMISE, {
    // Promise.resolve(x)
    resolve: function resolve(x) {
      return _promiseResolve(this, x);
    },
  });
  _export(
    _export.S +
      _export.F *
        !(
          USE_NATIVE$1 &&
          _iterDetect(function (iter) {
            $Promise.all(iter)["catch"](empty);
          })
        ),
    PROMISE,
    {
      //  Promise.all(iterable)
      all: function all(iterable) {
        var C = this;
        var capability = newPromiseCapability(C);
        var resolve = capability.resolve;
        var reject = capability.reject;
        var result = _perform(function () {
          var values = [];
          var index = 0;
          var remaining = 1;
          _forOf(iterable, false, function (promise) {
            var $index = index++;
            var alreadyCalled = false;
            values.push(undefined);
            remaining++;
            C.resolve(promise).then(function (value) {
              if (alreadyCalled) return;
              alreadyCalled = true;
              values[$index] = value;
              --remaining || resolve(values);
            }, reject);
          });
          --remaining || resolve(values);
        });
        if (result.e) reject(result.v);
        return capability.promise;
      },
      // Promise.race(iterable)
      race: function race(iterable) {
        var C = this;
        var capability = newPromiseCapability(C);
        var reject = capability.reject;
        var result = _perform(function () {
          _forOf(iterable, false, function (promise) {
            C.resolve(promise).then(capability.resolve, reject);
          });
        });
        if (result.e) reject(result.v);
        return capability.promise;
      },
    }
  );

  _wksDefine("asyncIterator");

  function unwrapExports(x) {
    return x &&
      x.__esModule &&
      Object.prototype.hasOwnProperty.call(x, "default")
      ? x["default"]
      : x;
  }

  function createCommonjsModule$1(fn, module) {
    return (
      (module = {
        exports: {},
      }),
      fn(module, module.exports),
      module.exports
    );
  }

  var _global$1 = createCommonjsModule$1(function (module) {
    var global = (module.exports =
      typeof window != "undefined" && window.Math == Math
        ? window
        : typeof self != "undefined" && self.Math == Math
        ? self // eslint-disable-next-line no-new-func
        : Function("return this")());
    if (typeof __g == "number") __g = global; // eslint-disable-line no-undef
  });

  var hasOwnProperty$1 = {}.hasOwnProperty;

  var _has$1 = function _has$1(it, key) {
    return hasOwnProperty$1.call(it, key);
  };

  var _fails$1 = function _fails$1(exec) {
    try {
      return !!exec();
    } catch (e) {
      return true;
    }
  };

  var _descriptors$1 = !_fails$1(function () {
    return (
      Object.defineProperty({}, "a", {
        get: function get() {
          return 7;
        },
      }).a != 7
    );
  });

  var _core$1 = createCommonjsModule$1(function (module) {
    var core = (module.exports = {
      version: "2.6.12",
    });
    if (typeof __e == "number") __e = core; // eslint-disable-line no-undef
  });

  _core$1.version;

  var _isObject$1 = function _isObject$1(it) {
    return _typeof(it) === "object" ? it !== null : typeof it === "function";
  };

  var _anObject$1 = function _anObject$1(it) {
    if (!_isObject$1(it)) throw TypeError(it + " is not an object!");
    return it;
  };

  var document$3 = _global$1.document; // typeof document.createElement is 'object' in old IE

  var is$1 = _isObject$1(document$3) && _isObject$1(document$3.createElement);

  var _domCreate$1 = function _domCreate$1(it) {
    return is$1 ? document$3.createElement(it) : {};
  };

  var _ie8DomDefine$1 =
    !_descriptors$1 &&
    !_fails$1(function () {
      return (
        Object.defineProperty(_domCreate$1("div"), "a", {
          get: function get() {
            return 7;
          },
        }).a != 7
      );
    }); // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string

  var _toPrimitive$1 = function _toPrimitive$1(it, S) {
    if (!_isObject$1(it)) return it;
    var fn, val;
    if (
      S &&
      typeof (fn = it.toString) == "function" &&
      !_isObject$1((val = fn.call(it)))
    )
      return val;
    if (
      typeof (fn = it.valueOf) == "function" &&
      !_isObject$1((val = fn.call(it)))
    )
      return val;
    if (
      !S &&
      typeof (fn = it.toString) == "function" &&
      !_isObject$1((val = fn.call(it)))
    )
      return val;
    throw TypeError("Can't convert object to primitive value");
  };

  var dP$6 = Object.defineProperty;
  var f$8 = _descriptors$1
    ? Object.defineProperty
    : function defineProperty(O, P, Attributes) {
        _anObject$1(O);

        P = _toPrimitive$1(P, true);

        _anObject$1(Attributes);

        if (_ie8DomDefine$1)
          try {
            return dP$6(O, P, Attributes);
          } catch (e) {
            /* empty */
          }
        if ("get" in Attributes || "set" in Attributes)
          throw TypeError("Accessors not supported!");
        if ("value" in Attributes) O[P] = Attributes.value;
        return O;
      };
  var _objectDp$1 = {
    f: f$8,
  };

  var _propertyDesc$1 = function _propertyDesc$1(bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value,
    };
  };

  var _hide$1 = _descriptors$1
    ? function (object, key, value) {
        return _objectDp$1.f(object, key, _propertyDesc$1(1, value));
      }
    : function (object, key, value) {
        object[key] = value;
        return object;
      };

  var id$1 = 0;
  var px$1 = Math.random();

  var _uid$1 = function _uid(key) {
    return "Symbol(".concat(
      key === undefined ? "" : key,
      ")_",
      (++id$1 + px$1).toString(36)
    );
  };

  var _library$1 = false;

  var _shared$1 = createCommonjsModule$1(function (module) {
    var SHARED = "__core-js_shared__";
    var store = _global$1[SHARED] || (_global$1[SHARED] = {});
    (module.exports = function (key, value) {
      return store[key] || (store[key] = value !== undefined ? value : {});
    })("versions", []).push({
      version: _core$1.version,
      mode: "global",
      copyright: "© 2020 Denis Pushkarev (zloirock.ru)",
    });
  });

  var _functionToString$1 = _shared$1(
    "native-function-to-string",
    Function.toString
  );

  var _redefine$1 = createCommonjsModule$1(function (module) {
    var SRC = _uid$1("src");

    var TO_STRING = "toString";

    var TPL = ("" + _functionToString$1).split(TO_STRING);

    _core$1.inspectSource = function (it) {
      return _functionToString$1.call(it);
    };

    (module.exports = function (O, key, val, safe) {
      var isFunction = typeof val == "function";
      if (isFunction) _has$1(val, "name") || _hide$1(val, "name", key);
      if (O[key] === val) return;
      if (isFunction)
        _has$1(val, SRC) ||
          _hide$1(val, SRC, O[key] ? "" + O[key] : TPL.join(String(key)));

      if (O === _global$1) {
        O[key] = val;
      } else if (!safe) {
        delete O[key];

        _hide$1(O, key, val);
      } else if (O[key]) {
        O[key] = val;
      } else {
        _hide$1(O, key, val);
      } // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
    })(Function.prototype, TO_STRING, function toString() {
      return (
        (typeof this == "function" && this[SRC]) ||
        _functionToString$1.call(this)
      );
    });
  });

  var _aFunction$1 = function _aFunction$1(it) {
    if (typeof it != "function") throw TypeError(it + " is not a function!");
    return it;
  };

  var _ctx$1 = function _ctx$1(fn, that, length) {
    _aFunction$1(fn);

    if (that === undefined) return fn;

    switch (length) {
      case 1:
        return function (a) {
          return fn.call(that, a);
        };

      case 2:
        return function (a, b) {
          return fn.call(that, a, b);
        };

      case 3:
        return function (a, b, c) {
          return fn.call(that, a, b, c);
        };
    }

    return function () /* ...args */
    {
      return fn.apply(that, arguments);
    };
  };

  var PROTOTYPE$3 = "prototype";

  var $export$1 = function $export$1(type, name, source) {
    var IS_FORCED = type & $export$1.F;
    var IS_GLOBAL = type & $export$1.G;
    var IS_STATIC = type & $export$1.S;
    var IS_PROTO = type & $export$1.P;
    var IS_BIND = type & $export$1.B;
    var target = IS_GLOBAL
      ? _global$1
      : IS_STATIC
      ? _global$1[name] || (_global$1[name] = {})
      : (_global$1[name] || {})[PROTOTYPE$3];
    var exports = IS_GLOBAL ? _core$1 : _core$1[name] || (_core$1[name] = {});
    var expProto = exports[PROTOTYPE$3] || (exports[PROTOTYPE$3] = {});
    var key, own, out, exp;
    if (IS_GLOBAL) source = name;

    for (key in source) {
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined; // export native or passed

      out = (own ? target : source)[key]; // bind timers to global for call from export context

      exp =
        IS_BIND && own
          ? _ctx$1(out, _global$1)
          : IS_PROTO && typeof out == "function"
          ? _ctx$1(Function.call, out)
          : out; // extend global

      if (target) _redefine$1(target, key, out, type & $export$1.U); // export

      if (exports[key] != out) _hide$1(exports, key, exp);
      if (IS_PROTO && expProto[key] != out) expProto[key] = out;
    }
  };

  _global$1.core = _core$1; // type bitmap

  $export$1.F = 1; // forced

  $export$1.G = 2; // global

  $export$1.S = 4; // static

  $export$1.P = 8; // proto

  $export$1.B = 16; // bind

  $export$1.W = 32; // wrap

  $export$1.U = 64; // safe

  $export$1.R = 128; // real proto method for `library`

  var _export$1 = $export$1;

  var _meta$1 = createCommonjsModule$1(function (module) {
    var META = _uid$1("meta");

    var setDesc = _objectDp$1.f;
    var id = 0;

    var isExtensible =
      Object.isExtensible ||
      function () {
        return true;
      };

    var FREEZE = !_fails$1(function () {
      return isExtensible(Object.preventExtensions({}));
    });

    var setMeta = function setMeta(it) {
      setDesc(it, META, {
        value: {
          i: "O" + ++id,
          // object ID
          w: {}, // weak collections IDs
        },
      });
    };

    var fastKey = function fastKey(it, create) {
      // return primitive with prefix
      if (!_isObject$1(it))
        return _typeof(it) == "symbol"
          ? it
          : (typeof it == "string" ? "S" : "P") + it;

      if (!_has$1(it, META)) {
        // can't set metadata to uncaught frozen object
        if (!isExtensible(it)) return "F"; // not necessary to add metadata

        if (!create) return "E"; // add missing metadata

        setMeta(it); // return object ID
      }

      return it[META].i;
    };

    var getWeak = function getWeak(it, create) {
      if (!_has$1(it, META)) {
        // can't set metadata to uncaught frozen object
        if (!isExtensible(it)) return true; // not necessary to add metadata

        if (!create) return false; // add missing metadata

        setMeta(it); // return hash weak collections IDs
      }

      return it[META].w;
    }; // add metadata on freeze-family methods calling

    var onFreeze = function onFreeze(it) {
      if (FREEZE && meta.NEED && isExtensible(it) && !_has$1(it, META))
        setMeta(it);
      return it;
    };

    var meta = (module.exports = {
      KEY: META,
      NEED: false,
      fastKey: fastKey,
      getWeak: getWeak,
      onFreeze: onFreeze,
    });
  });

  _meta$1.KEY;
  _meta$1.NEED;
  _meta$1.fastKey;
  _meta$1.getWeak;
  _meta$1.onFreeze;

  var _wks$1 = createCommonjsModule$1(function (module) {
    var store = _shared$1("wks");

    var _Symbol = _global$1.Symbol;
    var USE_SYMBOL = typeof _Symbol == "function";

    var $exports = (module.exports = function (name) {
      return (
        store[name] ||
        (store[name] =
          (USE_SYMBOL && _Symbol[name]) ||
          (USE_SYMBOL ? _Symbol : _uid$1)("Symbol." + name))
      );
    });

    $exports.store = store;
  });

  var def$1 = _objectDp$1.f;

  var TAG$1$1 = _wks$1("toStringTag");

  var _setToStringTag$1 = function _setToStringTag(it, tag, stat) {
    if (it && !_has$1((it = stat ? it : it.prototype), TAG$1$1))
      def$1(it, TAG$1$1, {
        configurable: true,
        value: tag,
      });
  };

  var f$7$1 = _wks$1;
  var _wksExt$1 = {
    f: f$7$1,
  };
  var defineProperty$1 = _objectDp$1.f;

  var _wksDefine$1 = function _wksDefine(name) {
    var $Symbol = _core$1.Symbol || (_core$1.Symbol = _global$1.Symbol || {});
    if (name.charAt(0) != "_" && !(name in $Symbol))
      defineProperty$1($Symbol, name, {
        value: _wksExt$1.f(name),
      });
  };

  var toString$1$1 = {}.toString;

  var _cof$1 = function _cof(it) {
    return toString$1$1.call(it).slice(8, -1);
  }; // eslint-disable-next-line no-prototype-builtins

  var _iobject$1 = Object("z").propertyIsEnumerable(0)
    ? Object
    : function (it) {
        return _cof$1(it) == "String" ? it.split("") : Object(it);
      }; //  RequireObjectCoercible(argument)

  var _defined$1 = function _defined(it) {
    if (it == undefined) throw TypeError("Can't call method on  " + it);
    return it;
  };

  var _toIobject$1 = function _toIobject(it) {
    return _iobject$1(_defined$1(it));
  }; //

  var ceil$1 = Math.ceil;
  var floor$3 = Math.floor;

  var _toInteger$1 = function _toInteger(it) {
    return isNaN((it = +it)) ? 0 : (it > 0 ? floor$3 : ceil$1)(it);
  };

  var min$2$1 = Math.min;

  var _toLength$1 = function _toLength(it) {
    return it > 0 ? min$2$1(_toInteger$1(it), 0x1fffffffffffff) : 0; //
  };

  var max$1$1 = Math.max;
  var min$1$1 = Math.min;

  var _toAbsoluteIndex$1 = function _toAbsoluteIndex(index, length) {
    index = _toInteger$1(index);
    return index < 0 ? max$1$1(index + length, 0) : min$1$1(index, length);
  }; // true  -> Array#includes

  var _arrayIncludes$1 = function _arrayIncludes(IS_INCLUDES) {
    return function ($this, el, fromIndex) {
      var O = _toIobject$1($this);

      var length = _toLength$1(O.length);

      var index = _toAbsoluteIndex$1(fromIndex, length);

      var value; // Array#includes uses SameValueZero equality algorithm
      // eslint-disable-next-line no-self-compare

      if (IS_INCLUDES && el != el)
        while (length > index) {
          value = O[index++]; // eslint-disable-next-line no-self-compare

          if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not
        }
      else
        for (; length > index; index++) {
          if (IS_INCLUDES || index in O) {
            if (O[index] === el) return IS_INCLUDES || index || 0;
          }
        }
      return !IS_INCLUDES && -1;
    };
  };

  var shared$1 = _shared$1("keys");

  var _sharedKey$1 = function _sharedKey(key) {
    return shared$1[key] || (shared$1[key] = _uid$1(key));
  };

  var arrayIndexOf$1 = _arrayIncludes$1(false);

  var IE_PROTO$2$1 = _sharedKey$1("IE_PROTO");

  var _objectKeysInternal$1 = function _objectKeysInternal(object, names) {
    var O = _toIobject$1(object);

    var i = 0;
    var result = [];
    var key;

    for (key in O) {
      if (key != IE_PROTO$2$1) _has$1(O, key) && result.push(key);
    } // Don't enum bug & hidden keys

    while (names.length > i) {
      if (_has$1(O, (key = names[i++]))) {
        ~arrayIndexOf$1(result, key) || result.push(key);
      }
    }

    return result;
  }; // IE 8- don't enum bug keys

  var _enumBugKeys$1 =
    "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(
      ","
    );

  var _objectKeys$1 =
    Object.keys ||
    function keys(O) {
      return _objectKeysInternal$1(O, _enumBugKeys$1);
    };

  var f$6$1 = Object.getOwnPropertySymbols;
  var _objectGops$1 = {
    f: f$6$1,
  };
  var f$5$1 = {}.propertyIsEnumerable;
  var _objectPie$1 = {
    f: f$5$1,
  };

  var _enumKeys$1 = function _enumKeys(it) {
    var result = _objectKeys$1(it);

    var getSymbols = _objectGops$1.f;

    if (getSymbols) {
      var symbols = getSymbols(it);
      var isEnum = _objectPie$1.f;
      var i = 0;
      var key;

      while (symbols.length > i) {
        if (isEnum.call(it, (key = symbols[i++]))) result.push(key);
      }
    }

    return result;
  };

  var _isArray$1 =
    Array.isArray ||
    function isArray(arg) {
      return _cof$1(arg) == "Array";
    };

  var _toObject$1 = function _toObject(it) {
    return Object(_defined$1(it));
  };

  var _objectDps$1 = _descriptors$1
    ? Object.defineProperties
    : function defineProperties(O, Properties) {
        _anObject$1(O);

        var keys = _objectKeys$1(Properties);

        var length = keys.length;
        var i = 0;
        var P;

        while (length > i) {
          _objectDp$1.f(O, (P = keys[i++]), Properties[P]);
        }

        return O;
      };

  var document$2$1 = _global$1.document;

  var _html$1 = document$2$1 && document$2$1.documentElement;

  var IE_PROTO$1$1 = _sharedKey$1("IE_PROTO");

  var Empty$1 = function Empty() {
    /* empty */
  };

  var PROTOTYPE$2$1 = "prototype"; // Create object with fake `null` prototype: use iframe Object with cleared prototype

  var _createDict = function createDict() {
    // Thrash, waste and sodomy: IE GC bug
    var iframe = _domCreate$1("iframe");

    var i = _enumBugKeys$1.length;
    var lt = "<";
    var gt = ">";
    var iframeDocument;
    iframe.style.display = "none";

    _html$1.appendChild(iframe);

    iframe.src = "javascript:"; // eslint-disable-line no-script-url
    // createDict = iframe.contentWindow.Object;
    // html.removeChild(iframe);

    iframeDocument = iframe.contentWindow.document;
    iframeDocument.open();
    iframeDocument.write(
      lt + "script" + gt + "document.F=Object" + lt + "/script" + gt
    );
    iframeDocument.close();
    _createDict = iframeDocument.F;

    while (i--) {
      delete _createDict[PROTOTYPE$2$1][_enumBugKeys$1[i]];
    }

    return _createDict();
  };

  var _objectCreate$1 =
    Object.create ||
    function create(O, Properties) {
      var result;

      if (O !== null) {
        Empty$1[PROTOTYPE$2$1] = _anObject$1(O);
        result = new Empty$1();
        Empty$1[PROTOTYPE$2$1] = null; // add "__proto__" for Object.getPrototypeOf polyfill

        result[IE_PROTO$1$1] = O;
      } else result = _createDict();

      return Properties === undefined
        ? result
        : _objectDps$1(result, Properties);
    };

  var hiddenKeys$1 = _enumBugKeys$1.concat("length", "prototype");

  var f$4$1 =
    Object.getOwnPropertyNames ||
    function getOwnPropertyNames(O) {
      return _objectKeysInternal$1(O, hiddenKeys$1);
    };

  var _objectGopn$1 = {
    f: f$4$1,
  };
  var gOPN$3$1 = _objectGopn$1.f;
  var toString$2 = {}.toString;
  var windowNames$1 =
    (typeof window === "undefined" ? "undefined" : _typeof(window)) ==
      "object" &&
    window &&
    Object.getOwnPropertyNames
      ? Object.getOwnPropertyNames(window)
      : [];

  var getWindowNames$1 = function getWindowNames(it) {
    try {
      return gOPN$3$1(it);
    } catch (e) {
      return windowNames$1.slice();
    }
  };

  var f$3$1 = function getOwnPropertyNames(it) {
    return windowNames$1 && toString$2.call(it) == "[object Window]"
      ? getWindowNames$1(it)
      : gOPN$3$1(_toIobject$1(it));
  };

  var _objectGopnExt$1 = {
    f: f$3$1,
  };
  var gOPD$3 = Object.getOwnPropertyDescriptor;
  var f$2$1 = _descriptors$1
    ? gOPD$3
    : function getOwnPropertyDescriptor(O, P) {
        O = _toIobject$1(O);
        P = _toPrimitive$1(P, true);
        if (_ie8DomDefine$1)
          try {
            return gOPD$3(O, P);
          } catch (e) {
            /* empty */
          }
        if (_has$1(O, P))
          return _propertyDesc$1(!_objectPie$1.f.call(O, P), O[P]);
      };
  var _objectGopd$1 = {
    f: f$2$1,
  };
  var META$1 = _meta$1.KEY;
  var gOPD$2$1 = _objectGopd$1.f;
  var dP$5 = _objectDp$1.f;
  var gOPN$2$1 = _objectGopnExt$1.f;
  var $Symbol$1 = _global$1.Symbol;
  var $JSON$1 = _global$1.JSON;

  var _stringify$1 = $JSON$1 && $JSON$1.stringify;

  var PROTOTYPE$1$1 = "prototype";

  var HIDDEN$1 = _wks$1("_hidden");

  var TO_PRIMITIVE$1 = _wks$1("toPrimitive");

  var isEnum$1 = {}.propertyIsEnumerable;

  var SymbolRegistry$1 = _shared$1("symbol-registry");

  var AllSymbols$1 = _shared$1("symbols");

  var OPSymbols$1 = _shared$1("op-symbols");

  var ObjectProto$1$1 = Object[PROTOTYPE$1$1];
  var USE_NATIVE$1$1 = typeof $Symbol$1 == "function" && !!_objectGops$1.f;
  var QObject$1 = _global$1.QObject; // Don't use setters in Qt Script,

  var setter$1 =
    !QObject$1 ||
    !QObject$1[PROTOTYPE$1$1] ||
    !QObject$1[PROTOTYPE$1$1].findChild; // fallback for old Android,

  var setSymbolDesc$1 =
    _descriptors$1 &&
    _fails$1(function () {
      return (
        _objectCreate$1(
          dP$5({}, "a", {
            get: function get() {
              return dP$5(this, "a", {
                value: 7,
              }).a;
            },
          })
        ).a != 7
      );
    })
      ? function (it, key, D) {
          var protoDesc = gOPD$2$1(ObjectProto$1$1, key);
          if (protoDesc) delete ObjectProto$1$1[key];
          dP$5(it, key, D);
          if (protoDesc && it !== ObjectProto$1$1)
            dP$5(ObjectProto$1$1, key, protoDesc);
        }
      : dP$5;

  var wrap$1 = function wrap$1(tag) {
    var sym = (AllSymbols$1[tag] = _objectCreate$1($Symbol$1[PROTOTYPE$1$1]));

    sym._k = tag;
    return sym;
  };

  var isSymbol$1 =
    USE_NATIVE$1$1 && _typeof($Symbol$1.iterator) == "symbol"
      ? function (it) {
          return _typeof(it) == "symbol";
        }
      : function (it) {
          return it instanceof $Symbol$1;
        };

  var $defineProperty$1 = function defineProperty(it, key, D) {
    if (it === ObjectProto$1$1) $defineProperty$1(OPSymbols$1, key, D);

    _anObject$1(it);

    key = _toPrimitive$1(key, true);

    _anObject$1(D);

    if (_has$1(AllSymbols$1, key)) {
      if (!D.enumerable) {
        if (!_has$1(it, HIDDEN$1)) dP$5(it, HIDDEN$1, _propertyDesc$1(1, {}));
        it[HIDDEN$1][key] = true;
      } else {
        if (_has$1(it, HIDDEN$1) && it[HIDDEN$1][key])
          it[HIDDEN$1][key] = false;
        D = _objectCreate$1(D, {
          enumerable: _propertyDesc$1(0, false),
        });
      }

      return setSymbolDesc$1(it, key, D);
    }

    return dP$5(it, key, D);
  };

  var $defineProperties$1 = function defineProperties(it, P) {
    _anObject$1(it);

    var keys = _enumKeys$1((P = _toIobject$1(P)));

    var i = 0;
    var l = keys.length;
    var key;

    while (l > i) {
      $defineProperty$1(it, (key = keys[i++]), P[key]);
    }

    return it;
  };

  var $create$1 = function create(it, P) {
    return P === undefined
      ? _objectCreate$1(it)
      : $defineProperties$1(_objectCreate$1(it), P);
  };

  var $propertyIsEnumerable$1 = function propertyIsEnumerable(key) {
    var E = isEnum$1.call(this, (key = _toPrimitive$1(key, true)));
    if (
      this === ObjectProto$1$1 &&
      _has$1(AllSymbols$1, key) &&
      !_has$1(OPSymbols$1, key)
    )
      return false;
    return E ||
      !_has$1(this, key) ||
      !_has$1(AllSymbols$1, key) ||
      (_has$1(this, HIDDEN$1) && this[HIDDEN$1][key])
      ? E
      : true;
  };

  var $getOwnPropertyDescriptor$1$1 = function getOwnPropertyDescriptor(
    it,
    key
  ) {
    it = _toIobject$1(it);
    key = _toPrimitive$1(key, true);
    if (
      it === ObjectProto$1$1 &&
      _has$1(AllSymbols$1, key) &&
      !_has$1(OPSymbols$1, key)
    )
      return;
    var D = gOPD$2$1(it, key);
    if (
      D &&
      _has$1(AllSymbols$1, key) &&
      !(_has$1(it, HIDDEN$1) && it[HIDDEN$1][key])
    )
      D.enumerable = true;
    return D;
  };

  var $getOwnPropertyNames$1 = function getOwnPropertyNames(it) {
    var names = gOPN$2$1(_toIobject$1(it));
    var result = [];
    var i = 0;
    var key;

    while (names.length > i) {
      if (
        !_has$1(AllSymbols$1, (key = names[i++])) &&
        key != HIDDEN$1 &&
        key != META$1
      )
        result.push(key);
    }

    return result;
  };

  var $getOwnPropertySymbols$1 = function getOwnPropertySymbols(it) {
    var IS_OP = it === ObjectProto$1$1;
    var names = gOPN$2$1(IS_OP ? OPSymbols$1 : _toIobject$1(it));
    var result = [];
    var i = 0;
    var key;

    while (names.length > i) {
      if (
        _has$1(AllSymbols$1, (key = names[i++])) &&
        (IS_OP ? _has$1(ObjectProto$1$1, key) : true)
      )
        result.push(AllSymbols$1[key]);
    }

    return result;
  }; // 19.4.1.1 Symbol([description])

  if (!USE_NATIVE$1$1) {
    $Symbol$1 = function _Symbol2() {
      if (this instanceof $Symbol$1)
        throw TypeError("Symbol is not a constructor!");

      var tag = _uid$1(arguments.length > 0 ? arguments[0] : undefined);

      var $set = function $set(value) {
        if (this === ObjectProto$1$1) $set.call(OPSymbols$1, value);
        if (_has$1(this, HIDDEN$1) && _has$1(this[HIDDEN$1], tag))
          this[HIDDEN$1][tag] = false;
        setSymbolDesc$1(this, tag, _propertyDesc$1(1, value));
      };

      if (_descriptors$1 && setter$1)
        setSymbolDesc$1(ObjectProto$1$1, tag, {
          configurable: true,
          set: $set,
        });
      return wrap$1(tag);
    };

    _redefine$1($Symbol$1[PROTOTYPE$1$1], "toString", function toString() {
      return this._k;
    });

    _objectGopd$1.f = $getOwnPropertyDescriptor$1$1;
    _objectDp$1.f = $defineProperty$1;
    _objectGopn$1.f = _objectGopnExt$1.f = $getOwnPropertyNames$1;
    _objectPie$1.f = $propertyIsEnumerable$1;
    _objectGops$1.f = $getOwnPropertySymbols$1;

    if (_descriptors$1 && !_library$1) {
      _redefine$1(
        ObjectProto$1$1,
        "propertyIsEnumerable",
        $propertyIsEnumerable$1,
        true
      );
    }

    _wksExt$1.f = function (name) {
      return wrap$1(_wks$1(name));
    };
  }

  _export$1(_export$1.G + _export$1.W + _export$1.F * !USE_NATIVE$1$1, {
    Symbol: $Symbol$1,
  });

  for (
    var es6Symbols$1 = //
        "hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(
          ","
        ),
      j$1$1 = 0;
    es6Symbols$1.length > j$1$1;

  ) {
    _wks$1(es6Symbols$1[j$1$1++]);
  }

  for (
    var wellKnownSymbols$1 = _objectKeys$1(_wks$1.store), k$1 = 0;
    wellKnownSymbols$1.length > k$1;

  ) {
    _wksDefine$1(wellKnownSymbols$1[k$1++]);
  }

  _export$1(_export$1.S + _export$1.F * !USE_NATIVE$1$1, "Symbol", {
    //  Symbol.for(key)
    for: function _for(key) {
      return _has$1(SymbolRegistry$1, (key += ""))
        ? SymbolRegistry$1[key]
        : (SymbolRegistry$1[key] = $Symbol$1(key));
    },
    //  Symbol.keyFor(sym)
    keyFor: function keyFor(sym) {
      if (!isSymbol$1(sym)) throw TypeError(sym + " is not a symbol!");

      for (var key in SymbolRegistry$1) {
        if (SymbolRegistry$1[key] === sym) return key;
      }
    },
    useSetter: function useSetter() {
      setter$1 = true;
    },
    useSimple: function useSimple() {
      setter$1 = false;
    },
  });

  _export$1(_export$1.S + _export$1.F * !USE_NATIVE$1$1, "Object", {
    //  Object.create(O [, Properties])
    create: $create$1,
    //  Object.defineProperty(O, P, Attributes)
    defineProperty: $defineProperty$1,
    //  Object.defineProperties(O, Properties)
    defineProperties: $defineProperties$1,
    //  Object.getOwnPropertyDescriptor(O, P)
    getOwnPropertyDescriptor: $getOwnPropertyDescriptor$1$1,
    //  Object.getOwnPropertyNames(O)
    getOwnPropertyNames: $getOwnPropertyNames$1,
    //  Object.getOwnPropertySymbols(O)
    getOwnPropertySymbols: $getOwnPropertySymbols$1,
  }); // Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives


  var FAILS_ON_PRIMITIVES$1 = _fails$1(function () {
    _objectGops$1.f(1);
  });

  _export$1(_export$1.S + _export$1.F * FAILS_ON_PRIMITIVES$1, "Object", {
    getOwnPropertySymbols: function getOwnPropertySymbols(it) {
      return _objectGops$1.f(_toObject$1(it));
    },
  }); //  JSON.stringify(value [, replacer [, space]])

  $JSON$1 &&
    _export$1(
      _export$1.S +
        _export$1.F *
          (!USE_NATIVE$1$1 ||
            _fails$1(function () {
              var S = $Symbol$1(); // MS Edge converts symbol values to JSON as {}
              // WebKit converts symbol values to JSON as null
              // V8 throws on boxed symbols

              return (
                _stringify$1([S]) != "[null]" ||
                _stringify$1({
                  a: S,
                }) != "{}" ||
                _stringify$1(Object(S)) != "{}"
              );
            })),
      "JSON",
      {
        stringify: function stringify(it) {
          var args = [it];
          var i = 1;
          var replacer, $replacer;

          while (arguments.length > i) {
            args.push(arguments[i++]);
          }

          $replacer = replacer = args[1];
          if ((!_isObject$1(replacer) && it === undefined) || isSymbol$1(it))
            return; // IE8 returns string on undefined

          if (!_isArray$1(replacer))
            replacer = function replacer(key, value) {
              if (typeof $replacer == "function")
                value = $replacer.call(this, key, value);
              if (!isSymbol$1(value)) return value;
            };
          args[1] = replacer;
          return _stringify$1.apply($JSON$1, args);
        },
      }
    ); //  Symbol.prototype[@@toPrimitive](hint)

  $Symbol$1[PROTOTYPE$1$1][TO_PRIMITIVE$1] ||
    _hide$1(
      $Symbol$1[PROTOTYPE$1$1],
      TO_PRIMITIVE$1,
      $Symbol$1[PROTOTYPE$1$1].valueOf
    ); //  Symbol.prototype[@@toStringTag]

  _setToStringTag$1($Symbol$1, "Symbol");

  _setToStringTag$1(Math, "Math", true);

  _setToStringTag$1(_global$1.JSON, "JSON", true);

  _export$1(_export$1.S, "Object", {
    create: _objectCreate$1,
  });

  _export$1(_export$1.S + _export$1.F * !_descriptors$1, "Object", {
    defineProperty: _objectDp$1.f,
  });

  _export$1(_export$1.S + _export$1.F * !_descriptors$1, "Object", {
    defineProperties: _objectDps$1,
  });

  var _objectSap$1 = function _objectSap(KEY, exec) {
    var fn = (_core$1.Object || {})[KEY] || Object[KEY];
    var exp = {};
    exp[KEY] = exec(fn);

    _export$1(
      _export$1.S +
        _export$1.F *
          _fails$1(function () {
            fn(1);
          }),
      "Object",
      exp
    );
  };

  var $getOwnPropertyDescriptor$2 = _objectGopd$1.f;

  _objectSap$1("getOwnPropertyDescriptor", function () {
    return function getOwnPropertyDescriptor(it, key) {
      return $getOwnPropertyDescriptor$2(_toIobject$1(it), key);
    };
  });

  var IE_PROTO$3 = _sharedKey$1("IE_PROTO");

  var ObjectProto$2 = Object.prototype;

  var _objectGpo$1 =
    Object.getPrototypeOf ||
    function (O) {
      O = _toObject$1(O);
      if (_has$1(O, IE_PROTO$3)) return O[IE_PROTO$3];

      if (typeof O.constructor == "function" && O instanceof O.constructor) {
        return O.constructor.prototype;
      }

      return O instanceof Object ? ObjectProto$2 : null;
    };

  _objectSap$1("getPrototypeOf", function () {
    return function getPrototypeOf(it) {
      return _objectGpo$1(_toObject$1(it));
    };
  });

  _objectSap$1("keys", function () {
    return function keys(it) {
      return _objectKeys$1(_toObject$1(it));
    };
  });

  _objectSap$1("getOwnPropertyNames", function () {
    return _objectGopnExt$1.f;
  });

  var meta$2 = _meta$1.onFreeze;

  _objectSap$1("freeze", function ($freeze) {
    return function freeze(it) {
      return $freeze && _isObject$1(it) ? $freeze(meta$2(it)) : it;
    };
  });

  var meta$1 = _meta$1.onFreeze;

  _objectSap$1("seal", function ($seal) {
    return function seal(it) {
      return $seal && _isObject$1(it) ? $seal(meta$1(it)) : it;
    };
  });

  var meta$3 = _meta$1.onFreeze;

  _objectSap$1("preventExtensions", function ($preventExtensions) {
    return function preventExtensions(it) {
      return $preventExtensions && _isObject$1(it)
        ? $preventExtensions(meta$3(it))
        : it;
    };
  });

  _objectSap$1("isFrozen", function ($isFrozen) {
    return function isFrozen(it) {
      return _isObject$1(it) ? ($isFrozen ? $isFrozen(it) : false) : true;
    };
  });

  _objectSap$1("isSealed", function ($isSealed) {
    return function isSealed(it) {
      return _isObject$1(it) ? ($isSealed ? $isSealed(it) : false) : true;
    };
  });

  _objectSap$1("isExtensible", function ($isExtensible) {
    return function isExtensible(it) {
      return _isObject$1(it)
        ? $isExtensible
          ? $isExtensible(it)
          : true
        : false;
    };
  });

  var $assign$1 = Object.assign; // should work with symbols and should have deterministic property order (V8 bug)

  var _objectAssign$1 =
    !$assign$1 ||
    _fails$1(function () {
      var A = {};
      var B = {}; // eslint-disable-next-line no-undef

      var S = Symbol();
      var K = "abcdefghijklmnopqrst";
      A[S] = 7;
      K.split("").forEach(function (k) {
        B[k] = k;
      });
      return (
        $assign$1({}, A)[S] != 7 || Object.keys($assign$1({}, B)).join("") != K
      );
    })
      ? function assign(target, source) {
          // eslint-disable-line no-unused-vars
          var T = _toObject$1(target);

          var aLen = arguments.length;
          var index = 1;
          var getSymbols = _objectGops$1.f;
          var isEnum = _objectPie$1.f;

          while (aLen > index) {
            var S = _iobject$1(arguments[index++]);

            var keys = getSymbols
              ? _objectKeys$1(S).concat(getSymbols(S))
              : _objectKeys$1(S);
            var length = keys.length;
            var j = 0;
            var key;

            while (length > j) {
              key = keys[j++];
              if (!_descriptors$1 || isEnum.call(S, key)) T[key] = S[key];
            }
          }

          return T;
        }
      : $assign$1;

  _export$1(_export$1.S + _export$1.F, "Object", {
    assign: _objectAssign$1,
  }); //  SameValue(x, y)

  var _sameValue$1 =
    Object.is ||
    function is(x, y) {
      // eslint-disable-next-line no-self-compare
      return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
    };

  _export$1(_export$1.S, "Object", {
    is: _sameValue$1,
  });
  /* eslint-disable no-proto */

  var check$1 = function check(O, proto) {
    _anObject$1(O);

    if (!_isObject$1(proto) && proto !== null)
      throw TypeError(proto + ": can't set as prototype!");
  };

  var _setProto$1 = {
    set:
      Object.setPrototypeOf ||
      ("__proto__" in {} // eslint-disable-line
        ? (function (test, buggy, set) {
            try {
              set = _ctx$1(
                Function.call,
                _objectGopd$1.f(Object.prototype, "__proto__").set,
                2
              );
              set(test, []);
              buggy = !(test instanceof Array);
            } catch (e) {
              buggy = true;
            }

            return function setPrototypeOf(O, proto) {
              check$1(O, proto);
              if (buggy) O.__proto__ = proto;
              else set(O, proto);
              return O;
            };
          })({}, false)
        : undefined),
    check: check$1,
  };

  _export$1(_export$1.S, "Object", {
    setPrototypeOf: _setProto$1.set,
  });

  var TAG$2 = _wks$1("toStringTag"); // ES3 wrong here

  var ARG$1 =
    _cof$1(
      (function () {
        return arguments;
      })()
    ) == "Arguments"; // fallback for IE11 Script Access Denied error

  var tryGet$1 = function tryGet(it, key) {
    try {
      return it[key];
    } catch (e) {
      /* empty */
    }
  };

  var _classof$1 = function _classof(it) {
    var O, T, B;
    return it === undefined
      ? "Undefined"
      : it === null
      ? "Null" // @@toStringTag case
      : typeof (T = tryGet$1((O = Object(it)), TAG$2)) == "string"
      ? T // builtinTag case
      : ARG$1
      ? _cof$1(O) // ES3 arguments fallback
      : (B = _cof$1(O)) == "Object" && typeof O.callee == "function"
      ? "Arguments"
      : B;
  };

  var test$1$1 = {};
  test$1$1[_wks$1("toStringTag")] = "z";

  if (test$1$1 + "" != "[object z]") {
    _redefine$1(
      Object.prototype,
      "toString",
      function toString() {
        return "[object " + _classof$1(this) + "]";
      },
      true
    );
  } // fast apply,

  var _invoke$1 = function _invoke(fn, args, that) {
    var un = that === undefined;

    switch (args.length) {
      case 0:
        return un ? fn() : fn.call(that);

      case 1:
        return un ? fn(args[0]) : fn.call(that, args[0]);

      case 2:
        return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);

      case 3:
        return un
          ? fn(args[0], args[1], args[2])
          : fn.call(that, args[0], args[1], args[2]);

      case 4:
        return un
          ? fn(args[0], args[1], args[2], args[3])
          : fn.call(that, args[0], args[1], args[2], args[3]);
    }

    return fn.apply(that, args);
  };

  var arraySlice$1$1 = [].slice;
  var factories$1 = {};

  var construct$1 = function construct(F, len, args) {
    if (!(len in factories$1)) {
      for (var n = [], i = 0; i < len; i++) {
        n[i] = "a[" + i + "]";
      } // eslint-disable-next-line no-new-func

      factories$1[len] = Function("F,a", "return new F(" + n.join(",") + ")");
    }

    return factories$1[len](F, args);
  };

  var _bind$1 =
    Function.bind ||
    function bind(
      that
      /* , ...args */
    ) {
      var fn = _aFunction$1(this);

      var partArgs = arraySlice$1$1.call(arguments, 1);

      var bound = function bound() /* args... */
      {
        var args = partArgs.concat(arraySlice$1$1.call(arguments));
        return this instanceof bound
          ? construct$1(fn, args.length, args)
          : _invoke$1(fn, args, that);
      };

      if (_isObject$1(fn.prototype)) bound.prototype = fn.prototype;
      return bound;
    };

  _export$1(_export$1.P, "Function", {
    bind: _bind$1,
  });

  var dP$4$1 = _objectDp$1.f;
  var FProto$1 = Function.prototype;
  var nameRE$1 = /^\s*function ([^ (]*)/;
  var NAME$1$1 = "name";

  NAME$1$1 in FProto$1 ||
    (_descriptors$1 &&
      dP$4$1(FProto$1, NAME$1$1, {
        configurable: true,
        get: function get() {
          try {
            return ("" + this).match(nameRE$1)[1];
          } catch (e) {
            return "";
          }
        },
      }));

  var HAS_INSTANCE = _wks$1("hasInstance");

  var FunctionProto = Function.prototype;

  if (!(HAS_INSTANCE in FunctionProto))
    _objectDp$1.f(FunctionProto, HAS_INSTANCE, {
      value: function value(O) {
        if (typeof this != "function" || !_isObject$1(O)) return false;
        if (!_isObject$1(this.prototype)) return O instanceof this; // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:

        while ((O = _objectGpo$1(O))) {
          if (this.prototype === O) return true;
        }

        return false;
      },
    });

  var _stringWs$1 =
    "\t\n\x0B\f\r \xA0\u1680\u180E\u2000\u2001\u2002\u2003" +
    "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF";

  var space$1 = "[" + _stringWs$1 + "]";
  var non$1 = "\u200B\x85";
  var ltrim$1 = RegExp("^" + space$1 + space$1 + "*");
  var rtrim$1 = RegExp(space$1 + space$1 + "*$");

  var exporter$1 = function exporter(KEY, exec, ALIAS) {
    var exp = {};

    var FORCE = _fails$1(function () {
      return !!_stringWs$1[KEY]() || non$1[KEY]() != non$1;
    });

    var fn = (exp[KEY] = FORCE ? exec(trim$1) : _stringWs$1[KEY]);
    if (ALIAS) exp[ALIAS] = fn;

    _export$1(_export$1.P + _export$1.F * FORCE, "String", exp);
  }; // 1 -> String#trimLeft
  // 2 -> String#trimRight
  // 3 -> String#trim

  var trim$1 = (exporter$1.trim = function (string, TYPE) {
    string = String(_defined$1(string));
    if (TYPE & 1) string = string.replace(ltrim$1, "");
    if (TYPE & 2) string = string.replace(rtrim$1, "");
    return string;
  });

  var _stringTrim$1 = exporter$1;
  var $parseInt$1 = _global$1.parseInt;
  var $trim$2$1 = _stringTrim$1.trim;
  var hex$1 = /^[-+]?0[xX]/;

  var _parseInt$1 =
    $parseInt$1(_stringWs$1 + "08") !== 8 ||
    $parseInt$1(_stringWs$1 + "0x16") !== 22
      ? function parseInt(str, radix) {
          var string = $trim$2$1(String(str), 3);
          return $parseInt$1(
            string,
            radix >>> 0 || (hex$1.test(string) ? 16 : 10)
          );
        }
      : $parseInt$1;

  _export$1(_export$1.G + _export$1.F * (parseInt != _parseInt$1), {
    parseInt: _parseInt$1,
  });

  var $parseFloat$1 = _global$1.parseFloat;
  var $trim$1$1 = _stringTrim$1.trim;

  var _parseFloat$1 =
    1 / $parseFloat$1(_stringWs$1 + "-0") !== -Infinity
      ? function parseFloat(str) {
          var string = $trim$1$1(String(str), 3);
          var result = $parseFloat$1(string);
          return result === 0 && string.charAt(0) == "-" ? -0 : result;
        }
      : $parseFloat$1;

  _export$1(_export$1.G + _export$1.F * (parseFloat != _parseFloat$1), {
    parseFloat: _parseFloat$1,
  });

  var setPrototypeOf$1 = _setProto$1.set;

  var _inheritIfRequired$1 = function _inheritIfRequired(that, target, C) {
    var S = target.constructor;
    var P;

    if (
      S !== C &&
      typeof S == "function" &&
      (P = S.prototype) !== C.prototype &&
      _isObject$1(P) &&
      setPrototypeOf$1
    ) {
      setPrototypeOf$1(that, P);
    }

    return that;
  };

  var gOPN$1$1 = _objectGopn$1.f;
  var gOPD$1$1 = _objectGopd$1.f;
  var dP$3$1 = _objectDp$1.f;
  var $trim$3 = _stringTrim$1.trim;
  var NUMBER$1 = "Number";
  var $Number$1 = _global$1[NUMBER$1];
  var Base$1$1 = $Number$1;
  var proto$3 = $Number$1.prototype; // Opera ~12 has broken Object#toString

  var BROKEN_COF$1 = _cof$1(_objectCreate$1(proto$3)) == NUMBER$1;
  var TRIM$1 = "trim" in String.prototype; //

  var toNumber$1 = function toNumber(argument) {
    var it = _toPrimitive$1(argument, false);

    if (typeof it == "string" && it.length > 2) {
      it = TRIM$1 ? it.trim() : $trim$3(it, 3);
      var first = it.charCodeAt(0);
      var third, radix, maxCode;

      if (first === 43 || first === 45) {
        third = it.charCodeAt(2);
        if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
      } else if (first === 48) {
        switch (it.charCodeAt(1)) {
          case 66:
          case 98:
            radix = 2;
            maxCode = 49;
            break;
          // fast equal /^0b[01]+$/i

          case 79:
          case 111:
            radix = 8;
            maxCode = 55;
            break;
          // fast equal /^0o[0-7]+$/i

          default:
            return +it;
        }

        for (
          var digits = it.slice(2), i = 0, l = digits.length, code;
          i < l;
          i++
        ) {
          code = digits.charCodeAt(i); // parseInt parses a string to a first unavailable symbol
          // but ToNumber should return NaN if a string contains unavailable symbols

          if (code < 48 || code > maxCode) return NaN;
        }

        return parseInt(digits, radix);
      }
    }

    return +it;
  };

  if (!$Number$1(" 0o1") || !$Number$1("0b1") || $Number$1("+0x1")) {
    $Number$1 = function Number(value) {
      var it = arguments.length < 1 ? 0 : value;
      var that = this;
      return that instanceof $Number$1 && // check on 1..constructor(foo) case
        (BROKEN_COF$1
          ? _fails$1(function () {
              proto$3.valueOf.call(that);
            })
          : _cof$1(that) != NUMBER$1)
        ? _inheritIfRequired$1(new Base$1$1(toNumber$1(it)), that, $Number$1)
        : toNumber$1(it);
    };

    for (
      var keys$1$1 = _descriptors$1
          ? gOPN$1$1(Base$1$1)
          : // ES3:
            (
              "MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY," + // ES6 (in case, if modules with ES6 Number statics required before):
              "EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER," +
              "MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger"
            ).split(","),
        j$2 = 0,
        key$1$1;
      keys$1$1.length > j$2;
      j$2++
    ) {
      if (
        _has$1(Base$1$1, (key$1$1 = keys$1$1[j$2])) &&
        !_has$1($Number$1, key$1$1)
      ) {
        dP$3$1($Number$1, key$1$1, gOPD$1$1(Base$1$1, key$1$1));
      }
    }

    $Number$1.prototype = proto$3;
    proto$3.constructor = $Number$1;

    _redefine$1(_global$1, NUMBER$1, $Number$1);
  }

  var _aNumberValue = function _aNumberValue(it, msg) {
    if (typeof it != "number" && _cof$1(it) != "Number") throw TypeError(msg);
    return +it;
  };

  var _stringRepeat$1 = function repeat(count) {
    var str = String(_defined$1(this));
    var res = "";

    var n = _toInteger$1(count);

    if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");

    for (; n > 0; (n >>>= 1) && (str += str)) {
      if (n & 1) res += str;
    }

    return res;
  };

  var $toFixed = (1.0).toFixed;
  var floor$2 = Math.floor;
  var data = [0, 0, 0, 0, 0, 0];
  var ERROR = "Number.toFixed: incorrect invocation!";
  var ZERO = "0";

  var multiply = function multiply(n, c) {
    var i = -1;
    var c2 = c;

    while (++i < 6) {
      c2 += n * data[i];
      data[i] = c2 % 1e7;
      c2 = floor$2(c2 / 1e7);
    }
  };

  var divide = function divide(n) {
    var i = 6;
    var c = 0;

    while (--i >= 0) {
      c += data[i];
      data[i] = floor$2(c / n);
      c = (c % n) * 1e7;
    }
  };

  var numToString = function numToString() {
    var i = 6;
    var s = "";

    while (--i >= 0) {
      if (s !== "" || i === 0 || data[i] !== 0) {
        var t = String(data[i]);
        s = s === "" ? t : s + _stringRepeat$1.call(ZERO, 7 - t.length) + t;
      }
    }

    return s;
  };

  var pow$1 = function pow$1(x, n, acc) {
    return n === 0
      ? acc
      : n % 2 === 1
      ? pow$1(x, n - 1, acc * x)
      : pow$1(x * x, n / 2, acc);
  };

  var log = function log(x) {
    var n = 0;
    var x2 = x;

    while (x2 >= 4096) {
      n += 12;
      x2 /= 4096;
    }

    while (x2 >= 2) {
      n += 1;
      x2 /= 2;
    }

    return n;
  };

  _export$1(
    _export$1.P +
      _export$1.F *
        ((!!$toFixed &&
          ((0.00008).toFixed(3) !== "0.000" ||
            (0.9).toFixed(0) !== "1" ||
            (1.255).toFixed(2) !== "1.25" ||
            (1000000000000000128.0).toFixed(0) !== "1000000000000000128")) ||
          !_fails$1(function () {
            // V8 ~ Android 4.3-
            $toFixed.call({});
          })),
    "Number",
    {
      toFixed: function toFixed(fractionDigits) {
        var x = _aNumberValue(this, ERROR);

        var f = _toInteger$1(fractionDigits);

        var s = "";
        var m = ZERO;
        var e, z, j, k;
        if (f < 0 || f > 20) throw RangeError(ERROR); // eslint-disable-next-line no-self-compare

        if (x != x) return "NaN";
        if (x <= -1e21 || x >= 1e21) return String(x);

        if (x < 0) {
          s = "-";
          x = -x;
        }

        if (x > 1e-21) {
          e = log(x * pow$1(2, 69, 1)) - 69;
          z = e < 0 ? x * pow$1(2, -e, 1) : x / pow$1(2, e, 1);
          z *= 0x10000000000000;
          e = 52 - e;

          if (e > 0) {
            multiply(0, z);
            j = f;

            while (j >= 7) {
              multiply(1e7, 0);
              j -= 7;
            }

            multiply(pow$1(10, j, 1), 0);
            j = e - 1;

            while (j >= 23) {
              divide(1 << 23);
              j -= 23;
            }

            divide(1 << j);
            multiply(1, 1);
            divide(2);
            m = numToString();
          } else {
            multiply(0, z);
            multiply(1 << -e, 0);
            m = numToString() + _stringRepeat$1.call(ZERO, f);
          }
        }

        if (f > 0) {
          k = m.length;
          m =
            s +
            (k <= f
              ? "0." + _stringRepeat$1.call(ZERO, f - k) + m
              : m.slice(0, k - f) + "." + m.slice(k - f));
        } else {
          m = s + m;
        }

        return m;
      },
    }
  );

  var $toPrecision = (1.0).toPrecision;

  _export$1(
    _export$1.P +
      _export$1.F *
        (_fails$1(function () {
          // IE7-
          return $toPrecision.call(1, undefined) !== "1";
        }) ||
          !_fails$1(function () {
            // V8 ~ Android 4.3-
            $toPrecision.call({});
          })),
    "Number",
    {
      toPrecision: function toPrecision(precision) {
        var that = _aNumberValue(
          this,
          "Number#toPrecision: incorrect invocation!"
        );

        return precision === undefined
          ? $toPrecision.call(that)
          : $toPrecision.call(that, precision);
      },
    }
  );

  _export$1(_export$1.S, "Number", {
    EPSILON: Math.pow(2, -52),
  });

  var _isFinite = _global$1.isFinite;

  _export$1(_export$1.S, "Number", {
    isFinite: function isFinite(it) {
      return typeof it == "number" && _isFinite(it);
    },
  });

  var floor$1$1 = Math.floor;

  var _isInteger = function isInteger(it) {
    return !_isObject$1(it) && isFinite(it) && floor$1$1(it) === it;
  };

  _export$1(_export$1.S, "Number", {
    isInteger: _isInteger,
  });

  _export$1(_export$1.S, "Number", {
    isNaN: function isNaN(number) {
      // eslint-disable-next-line no-self-compare
      return number != number;
    },
  });

  var abs$1 = Math.abs;

  _export$1(_export$1.S, "Number", {
    isSafeInteger: function isSafeInteger(number) {
      return _isInteger(number) && abs$1(number) <= 0x1fffffffffffff;
    },
  });

  _export$1(_export$1.S, "Number", {
    MAX_SAFE_INTEGER: 0x1fffffffffffff,
  });

  _export$1(_export$1.S, "Number", {
    MIN_SAFE_INTEGER: -0x1fffffffffffff,
  });

  _export$1(
    _export$1.S + _export$1.F * (Number.parseFloat != _parseFloat$1),
    "Number",
    {
      parseFloat: _parseFloat$1,
    }
  );

  _export$1(
    _export$1.S + _export$1.F * (Number.parseInt != _parseInt$1),
    "Number",
    {
      parseInt: _parseInt$1,
    }
  );

  var _mathLog1p$1 =
    Math.log1p ||
    function log1p(x) {
      return (x = +x) > -1e-8 && x < 1e-8 ? x - (x * x) / 2 : Math.log(1 + x);
    };

  var sqrt$1 = Math.sqrt;
  var $acosh$1 = Math.acosh;

  _export$1(
    _export$1.S +
      _export$1.F *
        !(
          $acosh$1 && // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
          Math.floor($acosh$1(Number.MAX_VALUE)) == 710 && // Tor Browser bug: Math.acosh(Infinity) -> NaN
          $acosh$1(Infinity) == Infinity
        ),
    "Math",
    {
      acosh: function acosh(x) {
        return (x = +x) < 1
          ? NaN
          : x > 94906265.62425156
          ? Math.log(x) + Math.LN2
          : _mathLog1p$1(x - 1 + sqrt$1(x - 1) * sqrt$1(x + 1));
      },
    }
  );

  var $asinh$1 = Math.asinh;

  function asinh$1(x) {
    return !isFinite((x = +x)) || x == 0
      ? x
      : x < 0
      ? -asinh$1(-x)
      : Math.log(x + Math.sqrt(x * x + 1));
  } // Tor Browser bug: Math.asinh(0) -> -0

  _export$1(
    _export$1.S + _export$1.F * !($asinh$1 && 1 / $asinh$1(0) > 0),
    "Math",
    {
      asinh: asinh$1,
    }
  );

  var $atanh$1 = Math.atanh; // Tor Browser bug: Math.atanh(-0) -> 0

  _export$1(
    _export$1.S + _export$1.F * !($atanh$1 && 1 / $atanh$1(-0) < 0),
    "Math",
    {
      atanh: function atanh(x) {
        return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;
      },
    }
  );

  var _mathSign$1 =
    Math.sign ||
    function sign(x) {
      // eslint-disable-next-line no-self-compare
      return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
    };

  _export$1(_export$1.S, "Math", {
    cbrt: function cbrt(x) {
      return _mathSign$1((x = +x)) * Math.pow(Math.abs(x), 1 / 3);
    },
  });

  _export$1(_export$1.S, "Math", {
    clz32: function clz32(x) {
      return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32;
    },
  });

  var exp$2 = Math.exp;

  _export$1(_export$1.S, "Math", {
    cosh: function cosh(x) {
      return (exp$2((x = +x)) + exp$2(-x)) / 2;
    },
  });

  var $expm1$1 = Math.expm1;

  var _mathExpm1$1 =
    !$expm1$1 || // Old FF bug
    $expm1$1(10) > 22025.465794806719 ||
    $expm1$1(10) < 22025.4657948067165168 || // Tor Browser bug
    $expm1$1(-2e-17) != -2e-17
      ? function expm1(x) {
          return (x = +x) == 0
            ? x
            : x > -1e-6 && x < 1e-6
            ? x + (x * x) / 2
            : Math.exp(x) - 1;
        }
      : $expm1$1;

  _export$1(_export$1.S + _export$1.F * (_mathExpm1$1 != Math.expm1), "Math", {
    expm1: _mathExpm1$1,
  });

  var pow$2 = Math.pow;
  var EPSILON$1 = pow$2(2, -52);
  var EPSILON32$1 = pow$2(2, -23);
  var MAX32$1 = pow$2(2, 127) * (2 - EPSILON32$1);
  var MIN32$1 = pow$2(2, -126);

  var roundTiesToEven$1 = function roundTiesToEven(n) {
    return n + 1 / EPSILON$1 - 1 / EPSILON$1;
  };

  var _mathFround$1 =
    Math.fround ||
    function fround(x) {
      var $abs = Math.abs(x);

      var $sign = _mathSign$1(x);

      var a, result;
      if ($abs < MIN32$1)
        return (
          $sign *
          roundTiesToEven$1($abs / MIN32$1 / EPSILON32$1) *
          MIN32$1 *
          EPSILON32$1
        );
      a = (1 + EPSILON32$1 / EPSILON$1) * $abs;
      result = a - (a - $abs); // eslint-disable-next-line no-self-compare

      if (result > MAX32$1 || result != result) return $sign * Infinity;
      return $sign * result;
    };

  _export$1(_export$1.S, "Math", {
    fround: _mathFround$1,
  });

  var abs = Math.abs;

  _export$1(_export$1.S, "Math", {
    hypot: function hypot(value1, value2) {
      // eslint-disable-line no-unused-vars
      var sum = 0;
      var i = 0;
      var aLen = arguments.length;
      var larg = 0;
      var arg, div;

      while (i < aLen) {
        arg = abs(arguments[i++]);

        if (larg < arg) {
          div = larg / arg;
          sum = sum * div * div + 1;
          larg = arg;
        } else if (arg > 0) {
          div = arg / larg;
          sum += div * div;
        } else sum += arg;
      }

      return larg === Infinity ? Infinity : larg * Math.sqrt(sum);
    },
  });

  var $imul$1 = Math.imul; // some WebKit versions fails with big numbers, some has wrong arity

  _export$1(
    _export$1.S +
      _export$1.F *
        _fails$1(function () {
          return $imul$1(0xffffffff, 5) != -5 || $imul$1.length != 2;
        }),
    "Math",
    {
      imul: function imul(x, y) {
        var UINT16 = 0xffff;
        var xn = +x;
        var yn = +y;
        var xl = UINT16 & xn;
        var yl = UINT16 & yn;
        return (
          0 |
          (xl * yl +
            ((((UINT16 & (xn >>> 16)) * yl + xl * (UINT16 & (yn >>> 16))) <<
              16) >>>
              0))
        );
      },
    }
  );

  _export$1(_export$1.S, "Math", {
    log10: function log10(x) {
      return Math.log(x) * Math.LOG10E;
    },
  });

  _export$1(_export$1.S, "Math", {
    log1p: _mathLog1p$1,
  });

  _export$1(_export$1.S, "Math", {
    log2: function log2(x) {
      return Math.log(x) / Math.LN2;
    },
  });

  _export$1(_export$1.S, "Math", {
    sign: _mathSign$1,
  });

  var exp$1 = Math.exp; // V8 near Chromium 38 has a problem with very small numbers

  _export$1(
    _export$1.S +
      _export$1.F *
        _fails$1(function () {
          return !Math.sinh(-2e-17) != -2e-17;
        }),
    "Math",
    {
      sinh: function sinh(x) {
        return Math.abs((x = +x)) < 1
          ? (_mathExpm1$1(x) - _mathExpm1$1(-x)) / 2
          : (exp$1(x - 1) - exp$1(-x - 1)) * (Math.E / 2);
      },
    }
  );

  var exp$3 = Math.exp;

  _export$1(_export$1.S, "Math", {
    tanh: function tanh(x) {
      var a = _mathExpm1$1((x = +x));

      var b = _mathExpm1$1(-x);

      return a == Infinity
        ? 1
        : b == Infinity
        ? -1
        : (a - b) / (exp$3(x) + exp$3(-x));
    },
  });

  _export$1(_export$1.S, "Math", {
    trunc: function trunc(it) {
      return (it > 0 ? Math.floor : Math.ceil)(it);
    },
  });

  var fromCharCode$1 = String.fromCharCode;
  var $fromCodePoint$1 = String.fromCodePoint; // length should be 1, old FF problem

  _export$1(
    _export$1.S +
      _export$1.F * (!!$fromCodePoint$1 && $fromCodePoint$1.length != 1),
    "String",
    {

      fromCodePoint: function fromCodePoint(x) {
        // eslint-disable-line no-unused-vars
        var res = [];
        var aLen = arguments.length;
        var i = 0;
        var code;

        while (aLen > i) {
          code = +arguments[i++];
          if (_toAbsoluteIndex$1(code, 0x10ffff) !== code)
            throw RangeError(code + " is not a valid code point");
          res.push(
            code < 0x10000
              ? fromCharCode$1(code)
              : fromCharCode$1(
                  ((code -= 0x10000) >> 10) + 0xd800,
                  (code % 0x400) + 0xdc00
                )
          );
        }

        return res.join("");
      },
    }
  );

  _export$1(_export$1.S, "String", {

    raw: function raw(callSite) {
      var tpl = _toIobject$1(callSite.raw);

      var len = _toLength$1(tpl.length);

      var aLen = arguments.length;
      var res = [];
      var i = 0;

      while (len > i) {
        res.push(String(tpl[i++]));
        if (i < aLen) res.push(String(arguments[i]));
      }

      return res.join("");
    },
  });

  _stringTrim$1("trim", function ($trim) {
    return function trim() {
      return $trim(this, 3);
    };
  }); // false -> String#codePointAt

  var _stringAt$1 = function _stringAt(TO_STRING) {
    return function (that, pos) {
      var s = String(_defined$1(that));

      var i = _toInteger$1(pos);

      var l = s.length;
      var a, b;
      if (i < 0 || i >= l) return TO_STRING ? "" : undefined;
      a = s.charCodeAt(i);
      return a < 0xd800 ||
        a > 0xdbff ||
        i + 1 === l ||
        (b = s.charCodeAt(i + 1)) < 0xdc00 ||
        b > 0xdfff
        ? TO_STRING
          ? s.charAt(i)
          : a
        : TO_STRING
        ? s.slice(i, i + 2)
        : ((a - 0xd800) << 10) + (b - 0xdc00) + 0x10000;
    };
  };

  var _iterators$1 = {};
  var IteratorPrototype$1 = {}; // %IteratorPrototype%[@@iterator]()

  _hide$1(IteratorPrototype$1, _wks$1("iterator"), function () {
    return this;
  });

  var _iterCreate$1 = function _iterCreate(Constructor, NAME, next) {
    Constructor.prototype = _objectCreate$1(IteratorPrototype$1, {
      next: _propertyDesc$1(1, next),
    });

    _setToStringTag$1(Constructor, NAME + " Iterator");
  };

  var ITERATOR$4$1 = _wks$1("iterator");

  var BUGGY$1 = !([].keys && "next" in [].keys()); // Safari has buggy iterators w/o `next`

  var FF_ITERATOR$1 = "@@iterator";
  var KEYS$1 = "keys";
  var VALUES$1 = "values";

  var returnThis$1 = function returnThis() {
    return this;
  };

  var _iterDefine$1 = function _iterDefine(
    Base,
    NAME,
    Constructor,
    next,
    DEFAULT,
    IS_SET,
    FORCED
  ) {
    _iterCreate$1(Constructor, NAME, next);

    var getMethod = function getMethod(kind) {
      if (!BUGGY$1 && kind in proto) return proto[kind];

      switch (kind) {
        case KEYS$1:
          return function keys() {
            return new Constructor(this, kind);
          };

        case VALUES$1:
          return function values() {
            return new Constructor(this, kind);
          };
      }

      return function entries() {
        return new Constructor(this, kind);
      };
    };

    var TAG = NAME + " Iterator";
    var DEF_VALUES = DEFAULT == VALUES$1;
    var VALUES_BUG = false;
    var proto = Base.prototype;
    var $native =
      proto[ITERATOR$4$1] ||
      proto[FF_ITERATOR$1] ||
      (DEFAULT && proto[DEFAULT]);
    var $default = $native || getMethod(DEFAULT);
    var $entries = DEFAULT
      ? !DEF_VALUES
        ? $default
        : getMethod("entries")
      : undefined;
    var $anyNative = NAME == "Array" ? proto.entries || $native : $native;
    var methods, key, IteratorPrototype; // Fix native

    if ($anyNative) {
      IteratorPrototype = _objectGpo$1($anyNative.call(new Base()));

      if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
        // Set @@toStringTag to native iterators
        _setToStringTag$1(IteratorPrototype, TAG, true); // fix for some old engines

        if (typeof IteratorPrototype[ITERATOR$4$1] != "function")
          _hide$1(IteratorPrototype, ITERATOR$4$1, returnThis$1);
      }
    } // fix Array#{values, @@iterator}.name in V8 / FF

    if (DEF_VALUES && $native && $native.name !== VALUES$1) {
      VALUES_BUG = true;

      $default = function values() {
        return $native.call(this);
      };
    } // Define iterator

    if (BUGGY$1 || VALUES_BUG || !proto[ITERATOR$4$1]) {
      _hide$1(proto, ITERATOR$4$1, $default);
    } // Plug for library

    _iterators$1[NAME] = $default;
    _iterators$1[TAG] = returnThis$1;

    if (DEFAULT) {
      methods = {
        values: DEF_VALUES ? $default : getMethod(VALUES$1),
        keys: IS_SET ? $default : getMethod(KEYS$1),
        entries: $entries,
      };
      if (FORCED)
        for (key in methods) {
          if (!(key in proto)) _redefine$1(proto, key, methods[key]);
        }
      else
        _export$1(
          _export$1.P + _export$1.F * (BUGGY$1 || VALUES_BUG),
          NAME,
          methods
        );
    }

    return methods;
  };

  var $at$1 = _stringAt$1(true); // String.prototype[@@iterator]()

  _iterDefine$1(
    String,
    "String",
    function (iterated) {
      this._t = String(iterated); // target

      this._i = 0; // next index
      // %StringIteratorPrototype%.next()
    },
    function () {
      var O = this._t;
      var index = this._i;
      var point;
      if (index >= O.length)
        return {
          value: undefined,
          done: true,
        };
      point = $at$1(O, index);
      this._i += point.length;
      return {
        value: point,
        done: false,
      };
    }
  );

  var $at$2 = _stringAt$1(false);

  _export$1(_export$1.P, "String", {
    // String.prototype.codePointAt(pos)
    codePointAt: function codePointAt(pos) {
      return $at$2(this, pos);
    },
  });

  var MATCH$1$1 = _wks$1("match");

  var _isRegexp$1 = function _isRegexp(it) {
    var isRegExp;
    return (
      _isObject$1(it) &&
      ((isRegExp = it[MATCH$1$1]) !== undefined
        ? !!isRegExp
        : _cof$1(it) == "RegExp")
    );
  };

  var _stringContext$1 = function _stringContext(that, searchString, NAME) {
    if (_isRegexp$1(searchString))
      throw TypeError("String#" + NAME + " doesn't accept regex!");
    return String(_defined$1(that));
  };

  var MATCH$2 = _wks$1("match");

  var _failsIsRegexp$1 = function _failsIsRegexp(KEY) {
    var re = /./;

    try {
      "/./"[KEY](re);
    } catch (e) {
      try {
        re[MATCH$2] = false;
        return !"/./"[KEY](re);
      } catch (f) {
        /* empty */
      }
    }

    return true;
  };

  var ENDS_WITH$1 = "endsWith";
  var $endsWith$1 = ""[ENDS_WITH$1];

  _export$1(
    _export$1.P + _export$1.F * _failsIsRegexp$1(ENDS_WITH$1),
    "String",
    {
      endsWith: function endsWith(
        searchString
        /* , endPosition = @length */
      ) {
        var that = _stringContext$1(this, searchString, ENDS_WITH$1);

        var endPosition = arguments.length > 1 ? arguments[1] : undefined;

        var len = _toLength$1(that.length);

        var end =
          endPosition === undefined
            ? len
            : Math.min(_toLength$1(endPosition), len);
        var search = String(searchString);
        return $endsWith$1
          ? $endsWith$1.call(that, search, end)
          : that.slice(end - search.length, end) === search;
      },
    }
  );

  var INCLUDES$1 = "includes";

  _export$1(
    _export$1.P + _export$1.F * _failsIsRegexp$1(INCLUDES$1),
    "String",
    {
      includes: function includes(
        searchString
        /* , position = 0 */
      ) {
        return !!~_stringContext$1(this, searchString, INCLUDES$1).indexOf(
          searchString,
          arguments.length > 1 ? arguments[1] : undefined
        );
      },
    }
  );

  _export$1(_export$1.P, "String", {
    //  String.prototype.repeat(count)
    repeat: _stringRepeat$1,
  });

  var STARTS_WITH$1 = "startsWith";
  var $startsWith$1 = ""[STARTS_WITH$1];

  _export$1(
    _export$1.P + _export$1.F * _failsIsRegexp$1(STARTS_WITH$1),
    "String",
    {
      startsWith: function startsWith(
        searchString
        /* , position = 0 */
      ) {
        var that = _stringContext$1(this, searchString, STARTS_WITH$1);

        var index = _toLength$1(
          Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length)
        );

        var search = String(searchString);
        return $startsWith$1
          ? $startsWith$1.call(that, search, index)
          : that.slice(index, index + search.length) === search;
      },
    }
  );

  var quot = /"/g; //  CreateHTML(string, tag, attribute, value)

  var createHTML = function createHTML(string, tag, attribute, value) {
    var S = String(_defined$1(string));
    var p1 = "<" + tag;
    if (attribute !== "")
      p1 +=
        " " + attribute + '="' + String(value).replace(quot, "&quot;") + '"';
    return p1 + ">" + S + "</" + tag + ">";
  };

  var _stringHtml = function _stringHtml(NAME, exec) {
    var O = {};
    O[NAME] = exec(createHTML);

    _export$1(
      _export$1.P +
        _export$1.F *
          _fails$1(function () {
            var test = ""[NAME]('"');
            return test !== test.toLowerCase() || test.split('"').length > 3;
          }),
      "String",
      O
    );
  };

  _stringHtml("anchor", function (createHTML) {
    return function anchor(name) {
      return createHTML(this, "a", "name", name);
    };
  });

  _stringHtml("big", function (createHTML) {
    return function big() {
      return createHTML(this, "big", "", "");
    };
  });

  _stringHtml("blink", function (createHTML) {
    return function blink() {
      return createHTML(this, "blink", "", "");
    };
  });

  _stringHtml("bold", function (createHTML) {
    return function bold() {
      return createHTML(this, "b", "", "");
    };
  });

  _stringHtml("fixed", function (createHTML) {
    return function fixed() {
      return createHTML(this, "tt", "", "");
    };
  });

  _stringHtml("fontcolor", function (createHTML) {
    return function fontcolor(color) {
      return createHTML(this, "font", "color", color);
    };
  });

  _stringHtml("fontsize", function (createHTML) {
    return function fontsize(size) {
      return createHTML(this, "font", "size", size);
    };
  });

  _stringHtml("italics", function (createHTML) {
    return function italics() {
      return createHTML(this, "i", "", "");
    };
  });

  _stringHtml("link", function (createHTML) {
    return function link(url) {
      return createHTML(this, "a", "href", url);
    };
  });

  _stringHtml("small", function (createHTML) {
    return function small() {
      return createHTML(this, "small", "", "");
    };
  });

  _stringHtml("strike", function (createHTML) {
    return function strike() {
      return createHTML(this, "strike", "", "");
    };
  });

  _stringHtml("sub", function (createHTML) {
    return function sub() {
      return createHTML(this, "sub", "", "");
    };
  });

  _stringHtml("sup", function (createHTML) {
    return function sup() {
      return createHTML(this, "sup", "", "");
    };
  });

  _export$1(_export$1.S, "Date", {
    now: function now() {
      return new Date().getTime();
    },
  });

  _export$1(
    _export$1.P +
      _export$1.F *
        _fails$1(function () {
          return (
            new Date(NaN).toJSON() !== null ||
            Date.prototype.toJSON.call({
              toISOString: function toISOString() {
                return 1;
              },
            }) !== 1
          );
        }),
    "Date",
    {
      // eslint-disable-next-line no-unused-vars
      toJSON: function toJSON(key) {
        var O = _toObject$1(this);

        var pv = _toPrimitive$1(O);

        return typeof pv == "number" && !isFinite(pv) ? null : O.toISOString();
      },
    }
  );

  var getTime$1$1 = Date.prototype.getTime;
  var $toISOString$1 = Date.prototype.toISOString;

  var lz$1 = function lz(num) {
    return num > 9 ? num : "0" + num;
  }; // PhantomJS / old WebKit has a broken implementations

  var _dateToIsoString$1 =
    _fails$1(function () {
      return (
        $toISOString$1.call(new Date(-5e13 - 1)) != "0385-07-25T07:06:39.999Z"
      );
    }) ||
    !_fails$1(function () {
      $toISOString$1.call(new Date(NaN));
    })
      ? function toISOString() {
          if (!isFinite(getTime$1$1.call(this)))
            throw RangeError("Invalid time value");
          var d = this;
          var y = d.getUTCFullYear();
          var m = d.getUTCMilliseconds();
          var s = y < 0 ? "-" : y > 9999 ? "+" : "";
          return (
            s +
            ("00000" + Math.abs(y)).slice(s ? -6 : -4) +
            "-" +
            lz$1(d.getUTCMonth() + 1) +
            "-" +
            lz$1(d.getUTCDate()) +
            "T" +
            lz$1(d.getUTCHours()) +
            ":" +
            lz$1(d.getUTCMinutes()) +
            ":" +
            lz$1(d.getUTCSeconds()) +
            "." +
            (m > 99 ? m : "0" + lz$1(m)) +
            "Z"
          );
        }
      : $toISOString$1; // PhantomJS / old WebKit has a broken implementations

  _export$1(
    _export$1.P +
      _export$1.F * (Date.prototype.toISOString !== _dateToIsoString$1),
    "Date",
    {
      toISOString: _dateToIsoString$1,
    }
  );

  var DateProto$1 = Date.prototype;
  var INVALID_DATE$1 = "Invalid Date";
  var TO_STRING$1$1 = "toString";
  var $toString$1$1 = DateProto$1[TO_STRING$1$1];
  var getTime$2 = DateProto$1.getTime;

  if (new Date(NaN) + "" != INVALID_DATE$1) {
    _redefine$1(DateProto$1, TO_STRING$1$1, function toString() {
      var value = getTime$2.call(this); // eslint-disable-next-line no-self-compare

      return value === value ? $toString$1$1.call(this) : INVALID_DATE$1;
    });
  }

  var NUMBER$2 = "number";

  var _dateToPrimitive = function _dateToPrimitive(hint) {
    if (hint !== "string" && hint !== NUMBER$2 && hint !== "default")
      throw TypeError("Incorrect hint");
    return _toPrimitive$1(_anObject$1(this), hint != NUMBER$2);
  };

  var TO_PRIMITIVE$2 = _wks$1("toPrimitive");

  var proto$2$1 = Date.prototype;
  if (!(TO_PRIMITIVE$2 in proto$2$1))
    _hide$1(proto$2$1, TO_PRIMITIVE$2, _dateToPrimitive);

  _export$1(_export$1.S, "Array", {
    isArray: _isArray$1,
  });

  var _iterCall$1 = function _iterCall(iterator, fn, value, entries) {
    try {
      return entries ? fn(_anObject$1(value)[0], value[1]) : fn(value); // IteratorClose(iterator, completion)
    } catch (e) {
      var ret = iterator["return"];
      if (ret !== undefined) _anObject$1(ret.call(iterator));
      throw e;
    }
  };

  var ITERATOR$3$1 = _wks$1("iterator");

  var ArrayProto$1$1 = Array.prototype;

  var _isArrayIter$1 = function _isArrayIter(it) {
    return (
      it !== undefined &&
      (_iterators$1.Array === it || ArrayProto$1$1[ITERATOR$3$1] === it)
    );
  };

  var _createProperty$1 = function _createProperty(object, index, value) {
    if (index in object)
      _objectDp$1.f(object, index, _propertyDesc$1(0, value));
    else object[index] = value;
  };

  var ITERATOR$2$1 = _wks$1("iterator");

  var core_getIteratorMethod$1 = (_core$1.getIteratorMethod = function (it) {
    if (it != undefined)
      return (
        it[ITERATOR$2$1] || it["@@iterator"] || _iterators$1[_classof$1(it)]
      );
  });

  var ITERATOR$1$1 = _wks$1("iterator");

  var SAFE_CLOSING$1 = false;

  try {
    var riter$1 = [7][ITERATOR$1$1]();

    riter$1["return"] = function () {
      SAFE_CLOSING$1 = true;
    }; // eslint-disable-next-line no-throw-literal

    Array.from(riter$1, function () {
      throw 2;
    });
  } catch (e) {
    /* empty */
  }

  var _iterDetect$1 = function _iterDetect(exec, skipClosing) {
    if (!skipClosing && !SAFE_CLOSING$1) return false;
    var safe = false;

    try {
      var arr = [7];
      var iter = arr[ITERATOR$1$1]();

      iter.next = function () {
        return {
          done: (safe = true),
        };
      };

      arr[ITERATOR$1$1] = function () {
        return iter;
      };

      exec(arr);
    } catch (e) {
      /* empty */
    }

    return safe;
  };

  _export$1(
    _export$1.S +
      _export$1.F *
        !_iterDetect$1(function (iter) {
          Array.from(iter);
        }),
    "Array",
    {
      // Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
      from: function from(
        arrayLike
        /* , mapfn = undefined, thisArg = undefined */
      ) {
        var O = _toObject$1(arrayLike);

        var C = typeof this == "function" ? this : Array;
        var aLen = arguments.length;
        var mapfn = aLen > 1 ? arguments[1] : undefined;
        var mapping = mapfn !== undefined;
        var index = 0;
        var iterFn = core_getIteratorMethod$1(O);
        var length, result, step, iterator;
        if (mapping)
          mapfn = _ctx$1(mapfn, aLen > 2 ? arguments[2] : undefined, 2); // if object isn't iterable or it's array with default iterator - use simple case

        if (iterFn != undefined && !(C == Array && _isArrayIter$1(iterFn))) {
          for (
            iterator = iterFn.call(O), result = new C();
            !(step = iterator.next()).done;
            index++
          ) {
            _createProperty$1(
              result,
              index,
              mapping
                ? _iterCall$1(iterator, mapfn, [step.value, index], true)
                : step.value
            );
          }
        } else {
          length = _toLength$1(O.length);

          for (result = new C(length); length > index; index++) {
            _createProperty$1(
              result,
              index,
              mapping ? mapfn(O[index], index) : O[index]
            );
          }
        }

        result.length = index;
        return result;
      },
    }
  );

  _export$1(
    _export$1.S +
      _export$1.F *
        _fails$1(function () {
          function F() {
            /* empty */
          }

          return !(Array.of.call(F) instanceof F);
        }),
    "Array",
    {
      // Array.of( ...items)
      of: function of() /* ...args */
      {
        var index = 0;
        var aLen = arguments.length;
        var result = new (typeof this == "function" ? this : Array)(aLen);

        while (aLen > index) {
          _createProperty$1(result, index, arguments[index++]);
        }

        result.length = aLen;
        return result;
      },
    }
  );

  var _strictMethod$1 = function _strictMethod(method, arg) {
    return (
      !!method &&
      _fails$1(function () {
        // eslint-disable-next-line no-useless-call
        arg
          ? method.call(
              null,
              function () {
                /* empty */
              },
              1
            )
          : method.call(null);
      })
    );
  };

  var arrayJoin = [].join; // fallback for not array-like strings

  _export$1(
    _export$1.P +
      _export$1.F * (_iobject$1 != Object || !_strictMethod$1(arrayJoin)),
    "Array",
    {
      join: function join(separator) {
        return arrayJoin.call(
          _toIobject$1(this),
          separator === undefined ? "," : separator
        );
      },
    }
  );

  var arraySlice$2 = [].slice; // fallback for not array-like ES3 strings and DOM objects

  _export$1(
    _export$1.P +
      _export$1.F *
        _fails$1(function () {
          if (_html$1) arraySlice$2.call(_html$1);
        }),
    "Array",
    {
      slice: function slice(begin, end) {
        var len = _toLength$1(this.length);

        var klass = _cof$1(this);

        end = end === undefined ? len : end;
        if (klass == "Array") return arraySlice$2.call(this, begin, end);

        var start = _toAbsoluteIndex$1(begin, len);

        var upTo = _toAbsoluteIndex$1(end, len);

        var size = _toLength$1(upTo - start);

        var cloned = new Array(size);
        var i = 0;

        for (; i < size; i++) {
          cloned[i] =
            klass == "String" ? this.charAt(start + i) : this[start + i];
        }

        return cloned;
      },
    }
  );

  var $sort$1 = [].sort;
  var test$2 = [1, 2, 3];

  _export$1(
    _export$1.P +
      _export$1.F *
        (_fails$1(function () {
          // IE8-
          test$2.sort(undefined);
        }) ||
          !_fails$1(function () {
            // V8 bug
            test$2.sort(null); // Old WebKit
          }) ||
          !_strictMethod$1($sort$1)),
    "Array",
    {
      // Array.prototype.sort(comparefn)
      sort: function sort(comparefn) {
        return comparefn === undefined
          ? $sort$1.call(_toObject$1(this))
          : $sort$1.call(_toObject$1(this), _aFunction$1(comparefn));
      },
    }
  );

  var SPECIES$3$1 = _wks$1("species");

  var _arraySpeciesConstructor$1 = function _arraySpeciesConstructor(original) {
    var C;

    if (_isArray$1(original)) {
      C = original.constructor; // cross-realm fallback

      if (typeof C == "function" && (C === Array || _isArray$1(C.prototype)))
        C = undefined;

      if (_isObject$1(C)) {
        C = C[SPECIES$3$1];
        if (C === null) C = undefined;
      }
    }

    return C === undefined ? Array : C;
  };

  var _arraySpeciesCreate$1 = function _arraySpeciesCreate(original, length) {
    return new (_arraySpeciesConstructor$1(original))(length);
  }; // 1 -> Array#map
  // 2 -> Array#filter
  // 3 -> Array#some
  // 4 -> Array#every
  // 5 -> Array#find
  // 6 -> Array#findIndex

  var _arrayMethods$1 = function _arrayMethods(TYPE, $create) {
    var IS_MAP = TYPE == 1;
    var IS_FILTER = TYPE == 2;
    var IS_SOME = TYPE == 3;
    var IS_EVERY = TYPE == 4;
    var IS_FIND_INDEX = TYPE == 6;
    var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
    var create = $create || _arraySpeciesCreate$1;
    return function ($this, callbackfn, that) {
      var O = _toObject$1($this);

      var self = _iobject$1(O);

      var f = _ctx$1(callbackfn, that, 3);

      var length = _toLength$1(self.length);

      var index = 0;
      var result = IS_MAP
        ? create($this, length)
        : IS_FILTER
        ? create($this, 0)
        : undefined;
      var val, res;

      for (; length > index; index++) {
        if (NO_HOLES || index in self) {
          val = self[index];
          res = f(val, index, O);

          if (TYPE) {
            if (IS_MAP) result[index] = res; // map
            else if (res)
              switch (TYPE) {
                case 3:
                  return true;
                // some

                case 5:
                  return val;
                // find

                case 6:
                  return index;
                // findIndex

                case 2:
                  result.push(val);
                // filter
              }
            else if (IS_EVERY) return false; // every
          }
        }
      }

      return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
    };
  };

  var $forEach$1 = _arrayMethods$1(0);

  var STRICT$1 = _strictMethod$1([].forEach, true);

  _export$1(_export$1.P + _export$1.F * !STRICT$1, "Array", {
    // Array.prototype.forEach(callbackfn [, thisArg])
    forEach: function forEach(
      callbackfn
      /* , thisArg */
    ) {
      return $forEach$1(this, callbackfn, arguments[1]);
    },
  });

  var $map$1 = _arrayMethods$1(1);

  _export$1(
    _export$1.P + _export$1.F * !_strictMethod$1([].map, true),
    "Array",
    {
      // Array.prototype.map(callbackfn [, thisArg])
      map: function map(
        callbackfn
        /* , thisArg */
      ) {
        return $map$1(this, callbackfn, arguments[1]);
      },
    }
  );

  var $filter$1 = _arrayMethods$1(2);

  _export$1(
    _export$1.P + _export$1.F * !_strictMethod$1([].filter, true),
    "Array",
    {
      //  Array.prototype.filter(callbackfn [, thisArg])
      filter: function filter(
        callbackfn
        /* , thisArg */
      ) {
        return $filter$1(this, callbackfn, arguments[1]);
      },
    }
  );

  var $some$1 = _arrayMethods$1(3);

  _export$1(
    _export$1.P + _export$1.F * !_strictMethod$1([].some, true),
    "Array",
    {
      // Array.prototype.some(callbackfn [, thisArg])
      some: function some(
        callbackfn
        /* , thisArg */
      ) {
        return $some$1(this, callbackfn, arguments[1]);
      },
    }
  );

  var $every$1 = _arrayMethods$1(4);

  _export$1(
    _export$1.P + _export$1.F * !_strictMethod$1([].every, true),
    "Array",
    {
      //  Array.prototype.every(callbackfn [, thisArg])
      every: function every(
        callbackfn
        /* , thisArg */
      ) {
        return $every$1(this, callbackfn, arguments[1]);
      },
    }
  );

  var _arrayReduce$1 = function _arrayReduce(
    that,
    callbackfn,
    aLen,
    memo,
    isRight
  ) {
    _aFunction$1(callbackfn);

    var O = _toObject$1(that);

    var self = _iobject$1(O);

    var length = _toLength$1(O.length);

    var index = isRight ? length - 1 : 0;
    var i = isRight ? -1 : 1;
    if (aLen < 2)
      for (;;) {
        if (index in self) {
          memo = self[index];
          index += i;
          break;
        }

        index += i;

        if (isRight ? index < 0 : length <= index) {
          throw TypeError("Reduce of empty array with no initial value");
        }
      }

    for (; isRight ? index >= 0 : length > index; index += i) {
      if (index in self) {
        memo = callbackfn(memo, self[index], index, O);
      }
    }

    return memo;
  };

  _export$1(
    _export$1.P + _export$1.F * !_strictMethod$1([].reduce, true),
    "Array",
    {
      //  Array.prototype.reduce(callbackfn [, initialValue])
      reduce: function reduce(
        callbackfn
        /* , initialValue */
      ) {
        return _arrayReduce$1(
          this,
          callbackfn,
          arguments.length,
          arguments[1],
          false
        );
      },
    }
  );

  _export$1(
    _export$1.P + _export$1.F * !_strictMethod$1([].reduceRight, true),
    "Array",
    {
      // Array.prototype.reduceRight(callbackfn [, initialValue])
      reduceRight: function reduceRight(
        callbackfn
        /* , initialValue */
      ) {
        return _arrayReduce$1(
          this,
          callbackfn,
          arguments.length,
          arguments[1],
          true
        );
      },
    }
  );

  var $indexOf$1 = _arrayIncludes$1(false);

  var $native$1$1 = [].indexOf;
  var NEGATIVE_ZERO$1$1 = !!$native$1$1 && 1 / [1].indexOf(1, -0) < 0;

  _export$1(
    _export$1.P +
      _export$1.F * (NEGATIVE_ZERO$1$1 || !_strictMethod$1($native$1$1)),
    "Array",
    {
      //  Array.prototype.indexOf(searchElement [, fromIndex])
      indexOf: function indexOf(
        searchElement
        /* , fromIndex = 0 */
      ) {
        return NEGATIVE_ZERO$1$1 // convert -0 to +0
          ? $native$1$1.apply(this, arguments) || 0
          : $indexOf$1(this, searchElement, arguments[1]);
      },
    }
  );

  var $native$2 = [].lastIndexOf;
  var NEGATIVE_ZERO$2 = !!$native$2 && 1 / [1].lastIndexOf(1, -0) < 0;

  _export$1(
    _export$1.P +
      _export$1.F * (NEGATIVE_ZERO$2 || !_strictMethod$1($native$2)),
    "Array",
    {
      //  Array.prototype.lastIndexOf(searchElement [, fromIndex])
      lastIndexOf: function lastIndexOf(
        searchElement
        /* , fromIndex = @[*-1] */
      ) {
        // convert -0 to +0
        if (NEGATIVE_ZERO$2) return $native$2.apply(this, arguments) || 0;

        var O = _toIobject$1(this);

        var length = _toLength$1(O.length);

        var index = length - 1;
        if (arguments.length > 1)
          index = Math.min(index, _toInteger$1(arguments[1]));
        if (index < 0) index = length + index;

        for (; index >= 0; index--) {
          if (index in O) if (O[index] === searchElement) return index || 0;
        }

        return -1;
      },
    }
  );

  var _arrayCopyWithin$1 =
    [].copyWithin ||
    function copyWithin(
      target,
      /* = 0 */
      start
      /* = 0, end = @length */
    ) {
      var O = _toObject$1(this);

      var len = _toLength$1(O.length);

      var to = _toAbsoluteIndex$1(target, len);

      var from = _toAbsoluteIndex$1(start, len);

      var end = arguments.length > 2 ? arguments[2] : undefined;
      var count = Math.min(
        (end === undefined ? len : _toAbsoluteIndex$1(end, len)) - from,
        len - to
      );
      var inc = 1;

      if (from < to && to < from + count) {
        inc = -1;
        from += count - 1;
        to += count - 1;
      }

      while (count-- > 0) {
        if (from in O) O[to] = O[from];
        else delete O[to];
        to += inc;
        from += inc;
      }

      return O;
    };

  var UNSCOPABLES$1 = _wks$1("unscopables");

  var ArrayProto$2 = Array.prototype;
  if (ArrayProto$2[UNSCOPABLES$1] == undefined)
    _hide$1(ArrayProto$2, UNSCOPABLES$1, {});

  var _addToUnscopables$1 = function _addToUnscopables(key) {
    ArrayProto$2[UNSCOPABLES$1][key] = true;
  };

  _export$1(_export$1.P, "Array", {
    copyWithin: _arrayCopyWithin$1,
  });

  _addToUnscopables$1("copyWithin");

  var _arrayFill$1 = function fill(
    value
    /* , start = 0, end = @length */
  ) {
    var O = _toObject$1(this);

    var length = _toLength$1(O.length);

    var aLen = arguments.length;

    var index = _toAbsoluteIndex$1(aLen > 1 ? arguments[1] : undefined, length);

    var end = aLen > 2 ? arguments[2] : undefined;
    var endPos = end === undefined ? length : _toAbsoluteIndex$1(end, length);

    while (endPos > index) {
      O[index++] = value;
    }

    return O;
  };

  _export$1(_export$1.P, "Array", {
    fill: _arrayFill$1,
  });

  _addToUnscopables$1("fill");

  var $find$1$1 = _arrayMethods$1(5);

  var KEY$1$1 = "find";
  var forced$1$1 = true; // Shouldn't skip holes

  if (KEY$1$1 in [])
    Array(1)[KEY$1$1](function () {
      forced$1$1 = false;
    });

  _export$1(_export$1.P + _export$1.F * forced$1$1, "Array", {
    find: function find(
      callbackfn
      /* , that = undefined */
    ) {
      return $find$1$1(
        this,
        callbackfn,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });

  _addToUnscopables$1(KEY$1$1);

  var $find$2 = _arrayMethods$1(6);

  var KEY$2 = "findIndex";
  var forced$2 = true; // Shouldn't skip holes

  if (KEY$2 in [])
    Array(1)[KEY$2](function () {
      forced$2 = false;
    });

  _export$1(_export$1.P + _export$1.F * forced$2, "Array", {
    findIndex: function findIndex(
      callbackfn
      /* , that = undefined */
    ) {
      return $find$2(
        this,
        callbackfn,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });

  _addToUnscopables$1(KEY$2);

  var SPECIES$2$1 = _wks$1("species");

  var _setSpecies$1 = function _setSpecies(KEY) {
    var C = _global$1[KEY];
    if (_descriptors$1 && C && !C[SPECIES$2$1])
      _objectDp$1.f(C, SPECIES$2$1, {
        configurable: true,
        get: function get() {
          return this;
        },
      });
  };

  _setSpecies$1("Array");

  var _iterStep$1 = function _iterStep(done, value) {
    return {
      value: value,
      done: !!done,
    };
  };

  var es6_array_iterator$1 = _iterDefine$1(
    Array,
    "Array",
    function (iterated, kind) {
      this._t = _toIobject$1(iterated); // target

      this._i = 0; // next index

      this._k = kind; // kind
    },
    function () {
      var O = this._t;
      var kind = this._k;
      var index = this._i++;

      if (!O || index >= O.length) {
        this._t = undefined;
        return _iterStep$1(1);
      }

      if (kind == "keys") return _iterStep$1(0, index);
      if (kind == "values") return _iterStep$1(0, O[index]);
      return _iterStep$1(0, [index, O[index]]);
    },
    "values"
  ); // argumentsList[@@iterator] is %ArrayProto_values%

  _iterators$1.Arguments = _iterators$1.Array;

  _addToUnscopables$1("keys");

  _addToUnscopables$1("values");

  _addToUnscopables$1("entries");

  var _flags$1 = function _flags() {
    var that = _anObject$1(this);

    var result = "";
    if (that.global) result += "g";
    if (that.ignoreCase) result += "i";
    if (that.multiline) result += "m";
    if (that.unicode) result += "u";
    if (that.sticky) result += "y";
    return result;
  };

  var dP$2$1 = _objectDp$1.f;
  var gOPN$4 = _objectGopn$1.f;
  var $RegExp$1 = _global$1.RegExp;
  var Base$2 = $RegExp$1;
  var proto$1$1 = $RegExp$1.prototype;
  var re1$1 = /a/g;
  var re2$1 = /a/g; // "new" creates a new object, old webkit buggy here

  var CORRECT_NEW$1 = new $RegExp$1(re1$1) !== re1$1;

  if (
    _descriptors$1 &&
    (!CORRECT_NEW$1 ||
      _fails$1(function () {
        re2$1[_wks$1("match")] = false; // RegExp constructor can alter flags and IsRegExp works correct with @@match

        return (
          $RegExp$1(re1$1) != re1$1 ||
          $RegExp$1(re2$1) == re2$1 ||
          $RegExp$1(re1$1, "i") != "/a/i"
        );
      }))
  ) {
    $RegExp$1 = function RegExp(p, f) {
      var tiRE = this instanceof $RegExp$1;

      var piRE = _isRegexp$1(p);

      var fiU = f === undefined;
      return !tiRE && piRE && p.constructor === $RegExp$1 && fiU
        ? p
        : _inheritIfRequired$1(
            CORRECT_NEW$1
              ? new Base$2(piRE && !fiU ? p.source : p, f)
              : Base$2(
                  (piRE = p instanceof $RegExp$1) ? p.source : p,
                  piRE && fiU ? _flags$1.call(p) : f
                ),
            tiRE ? this : proto$1$1,
            $RegExp$1
          );
    };

    var proxy$1 = function proxy(key) {
      key in $RegExp$1 ||
        dP$2$1($RegExp$1, key, {
          configurable: true,
          get: function get() {
            return Base$2[key];
          },
          set: function set(it) {
            Base$2[key] = it;
          },
        });
    };

    for (var keys$2 = gOPN$4(Base$2), i$2$1 = 0; keys$2.length > i$2$1; ) {
      proxy$1(keys$2[i$2$1++]);
    }

    proto$1$1.constructor = $RegExp$1;
    $RegExp$1.prototype = proto$1$1;

    _redefine$1(_global$1, "RegExp", $RegExp$1);
  }

  _setSpecies$1("RegExp");

  var nativeExec$1 = RegExp.prototype.exec; // This always refers to the native implementation, because the
  // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
  // which loads this file before patching the method.

  var nativeReplace$1 = String.prototype.replace;
  var patchedExec$1 = nativeExec$1;
  var LAST_INDEX$1$1 = "lastIndex";

  var UPDATES_LAST_INDEX_WRONG$1 = (function () {
    var re1 = /a/,
      re2 = /b*/g;
    nativeExec$1.call(re1, "a");
    nativeExec$1.call(re2, "a");
    return re1[LAST_INDEX$1$1] !== 0 || re2[LAST_INDEX$1$1] !== 0;
  })(); // nonparticipating capturing group, copied from es5-shim's String#split patch.

  var NPCG_INCLUDED$1 = /()??/.exec("")[1] !== undefined;
  var PATCH$1 = UPDATES_LAST_INDEX_WRONG$1 || NPCG_INCLUDED$1;

  if (PATCH$1) {
    patchedExec$1 = function exec(str) {
      var re = this;
      var lastIndex, reCopy, match, i;

      if (NPCG_INCLUDED$1) {
        reCopy = new RegExp("^" + re.source + "$(?!\\s)", _flags$1.call(re));
      }

      if (UPDATES_LAST_INDEX_WRONG$1) lastIndex = re[LAST_INDEX$1$1];
      match = nativeExec$1.call(re, str);

      if (UPDATES_LAST_INDEX_WRONG$1 && match) {
        re[LAST_INDEX$1$1] = re.global
          ? match.index + match[0].length
          : lastIndex;
      }

      if (NPCG_INCLUDED$1 && match && match.length > 1) {
        // Fix browsers whose `exec` methods don't consistently return `undefined`
        // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
        // eslint-disable-next-line no-loop-func
        nativeReplace$1.call(match[0], reCopy, function () {
          for (i = 1; i < arguments.length - 2; i++) {
            if (arguments[i] === undefined) match[i] = undefined;
          }
        });
      }

      return match;
    };
  }

  var _regexpExec$1 = patchedExec$1;

  _export$1(
    {
      target: "RegExp",
      proto: true,
      forced: _regexpExec$1 !== /./.exec,
    },
    {
      exec: _regexpExec$1,
    }
  );

  if (_descriptors$1 && /./g.flags != "g")
    _objectDp$1.f(RegExp.prototype, "flags", {
      configurable: true,
      get: _flags$1,
    });
  var TO_STRING$2 = "toString";
  var $toString$2 = /./[TO_STRING$2];

  var define$1 = function define(fn) {
    _redefine$1(RegExp.prototype, TO_STRING$2, fn, true);
  };

  if (
    _fails$1(function () {
      return (
        $toString$2.call({
          source: "a",
          flags: "b",
        }) != "/a/b"
      );
    })
  ) {
    define$1(function toString() {
      var R = _anObject$1(this);

      return "/".concat(
        R.source,
        "/",
        "flags" in R
          ? R.flags
          : !_descriptors$1 && R instanceof RegExp
          ? _flags$1.call(R)
          : undefined
      );
    }); // FF44- RegExp#toString has a wrong name
  } else if ($toString$2.name != TO_STRING$2) {
    define$1(function toString() {
      return $toString$2.call(this);
    });
  }

  var at$1 = _stringAt$1(true); // `AdvanceStringIndex` abstract operation


  var _advanceStringIndex$1 = function _advanceStringIndex(S, index, unicode) {
    return index + (unicode ? at$1(S, index).length : 1);
  };

  var builtinExec$1 = RegExp.prototype.exec; // `RegExpExec` abstract operation


  var _regexpExecAbstract$1 = function _regexpExecAbstract(R, S) {
    var exec = R.exec;

    if (typeof exec === "function") {
      var result = exec.call(R, S);

      if (_typeof(result) !== "object") {
        throw new TypeError(
          "RegExp exec method returned something other than an Object or null"
        );
      }

      return result;
    }

    if (_classof$1(R) !== "RegExp") {
      throw new TypeError("RegExp#exec called on incompatible receiver");
    }

    return builtinExec$1.call(R, S);
  };

  var SPECIES$1$1 = _wks$1("species");

  var REPLACE_SUPPORTS_NAMED_GROUPS$1 = !_fails$1(function () {
    // #replace needs built-in support for named groups.
    // #match works fine because it just return the exec results, even if it has
    // a "grops" property.
    var re = /./;

    re.exec = function () {
      var result = [];
      result.groups = {
        a: "7",
      };
      return result;
    };

    return "".replace(re, "$<a>") !== "7";
  });

  var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC$1 = (function () {
    // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
    var re = /(?:)/;
    var originalExec = re.exec;

    re.exec = function () {
      return originalExec.apply(this, arguments);
    };

    var result = "ab".split(re);
    return result.length === 2 && result[0] === "a" && result[1] === "b";
  })();

  var _fixReWks$1 = function _fixReWks(KEY, length, exec) {
    var SYMBOL = _wks$1(KEY);

    var DELEGATES_TO_SYMBOL = !_fails$1(function () {
      // String methods call symbol-named RegEp methods
      var O = {};

      O[SYMBOL] = function () {
        return 7;
      };

      return ""[KEY](O) != 7;
    });
    var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL
      ? !_fails$1(function () {
          // Symbol-named RegExp methods call .exec
          var execCalled = false;
          var re = /a/;

          re.exec = function () {
            execCalled = true;
            return null;
          };

          if (KEY === "split") {
            // RegExp[@@split] doesn't call the regex's exec method, but first creates
            // a new one. We need to return the patched regex when creating the new one.
            re.constructor = {};

            re.constructor[SPECIES$1$1] = function () {
              return re;
            };
          }

          re[SYMBOL]("");
          return !execCalled;
        })
      : undefined;

    if (
      !DELEGATES_TO_SYMBOL ||
      !DELEGATES_TO_EXEC ||
      (KEY === "replace" && !REPLACE_SUPPORTS_NAMED_GROUPS$1) ||
      (KEY === "split" && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC$1)
    ) {
      var nativeRegExpMethod = /./[SYMBOL];
      var fns = exec(
        _defined$1,
        SYMBOL,
        ""[KEY],
        function maybeCallNative(
          nativeMethod,
          regexp,
          str,
          arg2,
          forceStringMethod
        ) {
          if (regexp.exec === _regexpExec$1) {
            if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
              // The native String method already delegates to @@method (this
              // polyfilled function), leasing to infinite recursion.
              // We avoid it by directly calling the native @@method method.
              return {
                done: true,
                value: nativeRegExpMethod.call(regexp, str, arg2),
              };
            }

            return {
              done: true,
              value: nativeMethod.call(str, regexp, arg2),
            };
          }

          return {
            done: false,
          };
        }
      );
      var strfn = fns[0];
      var rxfn = fns[1];

      _redefine$1(String.prototype, KEY, strfn);

      _hide$1(
        RegExp.prototype,
        SYMBOL,
        length == 2 // RegExp.prototype[@@replace](string, replaceValue)
          ? //  RegExp.prototype[@@split](string, limit)
            function (string, arg) {
              return rxfn.call(string, this, arg);
            } //  RegExp.prototype[@@match](string)
          : //  RegExp.prototype[@@search](string)
            function (string) {
              return rxfn.call(string, this);
            }
      );
    }
  };

  _fixReWks$1("match", 1, function (defined, MATCH, $match, maybeCallNative) {
    return [
      // `String.prototype.match` method

      function match(regexp) {
        var O = defined(this);
        var fn = regexp == undefined ? undefined : regexp[MATCH];
        return fn !== undefined
          ? fn.call(regexp, O)
          : new RegExp(regexp)[MATCH](String(O));
      }, // `RegExp.prototype[@@match]` method

      function (regexp) {
        var res = maybeCallNative($match, regexp, this);
        if (res.done) return res.value;

        var rx = _anObject$1(regexp);

        var S = String(this);
        if (!rx.global) return _regexpExecAbstract$1(rx, S);
        var fullUnicode = rx.unicode;
        rx.lastIndex = 0;
        var A = [];
        var n = 0;
        var result;

        while ((result = _regexpExecAbstract$1(rx, S)) !== null) {
          var matchStr = String(result[0]);
          A[n] = matchStr;
          if (matchStr === "")
            rx.lastIndex = _advanceStringIndex$1(
              S,
              _toLength$1(rx.lastIndex),
              fullUnicode
            );
          n++;
        }

        return n === 0 ? null : A;
      },
    ];
  });

  var max$2 = Math.max;
  var min$3 = Math.min;
  var floor$4 = Math.floor;
  var SUBSTITUTION_SYMBOLS$1 = /\$([$&`']|\d\d?|<[^>]*>)/g;
  var SUBSTITUTION_SYMBOLS_NO_NAMED$1 = /\$([$&`']|\d\d?)/g;

  var maybeToString$1 = function maybeToString(it) {
    return it === undefined ? it : String(it);
  }; // @@replace logic

  _fixReWks$1(
    "replace",
    2,
    function (defined, REPLACE, $replace, maybeCallNative) {
      return [
        // `String.prototype.replace` method

        function replace(searchValue, replaceValue) {
          var O = defined(this);
          var fn = searchValue == undefined ? undefined : searchValue[REPLACE];
          return fn !== undefined
            ? fn.call(searchValue, O, replaceValue)
            : $replace.call(String(O), searchValue, replaceValue);
        }, // `RegExp.prototype[@@replace]` method

        function (regexp, replaceValue) {
          var res = maybeCallNative($replace, regexp, this, replaceValue);
          if (res.done) return res.value;

          var rx = _anObject$1(regexp);

          var S = String(this);
          var functionalReplace = typeof replaceValue === "function";
          if (!functionalReplace) replaceValue = String(replaceValue);
          var global = rx.global;

          if (global) {
            var fullUnicode = rx.unicode;
            rx.lastIndex = 0;
          }

          var results = [];

          while (true) {
            var result = _regexpExecAbstract$1(rx, S);

            if (result === null) break;
            results.push(result);
            if (!global) break;
            var matchStr = String(result[0]);
            if (matchStr === "")
              rx.lastIndex = _advanceStringIndex$1(
                S,
                _toLength$1(rx.lastIndex),
                fullUnicode
              );
          }

          var accumulatedResult = "";
          var nextSourcePosition = 0;

          for (var i = 0; i < results.length; i++) {
            result = results[i];
            var matched = String(result[0]);
            var position = max$2(
              min$3(_toInteger$1(result.index), S.length),
              0
            );
            var captures = []; // NOTE: This is equivalent to
            //   captures = result.slice(1).map(maybeToString)
            // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
            // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
            // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.

            for (var j = 1; j < result.length; j++) {
              captures.push(maybeToString$1(result[j]));
            }

            var namedCaptures = result.groups;

            if (functionalReplace) {
              var replacerArgs = [matched].concat(captures, position, S);
              if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
              var replacement = String(
                replaceValue.apply(undefined, replacerArgs)
              );
            } else {
              replacement = getSubstitution(
                matched,
                S,
                position,
                captures,
                namedCaptures,
                replaceValue
              );
            }

            if (position >= nextSourcePosition) {
              accumulatedResult +=
                S.slice(nextSourcePosition, position) + replacement;
              nextSourcePosition = position + matched.length;
            }
          }

          return accumulatedResult + S.slice(nextSourcePosition);
        },
      ];

      function getSubstitution(
        matched,
        str,
        position,
        captures,
        namedCaptures,
        replacement
      ) {
        var tailPos = position + matched.length;
        var m = captures.length;
        var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED$1;

        if (namedCaptures !== undefined) {
          namedCaptures = _toObject$1(namedCaptures);
          symbols = SUBSTITUTION_SYMBOLS$1;
        }

        return $replace.call(replacement, symbols, function (match, ch) {
          var capture;

          switch (ch.charAt(0)) {
            case "$":
              return "$";

            case "&":
              return matched;

            case "`":
              return str.slice(0, position);

            case "'":
              return str.slice(tailPos);

            case "<":
              capture = namedCaptures[ch.slice(1, -1)];
              break;

            default:
              // \d\d?
              var n = +ch;
              if (n === 0) return match;

              if (n > m) {
                var f = floor$4(n / 10);
                if (f === 0) return match;
                if (f <= m)
                  return captures[f - 1] === undefined
                    ? ch.charAt(1)
                    : captures[f - 1] + ch.charAt(1);
                return match;
              }

              capture = captures[n - 1];
          }

          return capture === undefined ? "" : capture;
        });
      }
    }
  );

  _fixReWks$1(
    "search",
    1,
    function (defined, SEARCH, $search, maybeCallNative) {
      return [
        // `String.prototype.search` method

        function search(regexp) {
          var O = defined(this);
          var fn = regexp == undefined ? undefined : regexp[SEARCH];
          return fn !== undefined
            ? fn.call(regexp, O)
            : new RegExp(regexp)[SEARCH](String(O));
        }, // `RegExp.prototype[@@search]` method

        function (regexp) {
          var res = maybeCallNative($search, regexp, this);
          if (res.done) return res.value;

          var rx = _anObject$1(regexp);

          var S = String(this);
          var previousLastIndex = rx.lastIndex;
          if (!_sameValue$1(previousLastIndex, 0)) rx.lastIndex = 0;

          var result = _regexpExecAbstract$1(rx, S);

          if (!_sameValue$1(rx.lastIndex, previousLastIndex))
            rx.lastIndex = previousLastIndex;
          return result === null ? -1 : result.index;
        },
      ];
    }
  );

  var SPECIES$4 = _wks$1("species");

  var _speciesConstructor$1 = function _speciesConstructor(O, D) {
    var C = _anObject$1(O).constructor;

    var S;
    return C === undefined || (S = _anObject$1(C)[SPECIES$4]) == undefined
      ? D
      : _aFunction$1(S);
  };

  var $min$1 = Math.min;
  var $push$1 = [].push;
  var $SPLIT$1 = "split";
  var LENGTH$1 = "length";
  var LAST_INDEX$2 = "lastIndex";
  var MAX_UINT32$1 = 0xffffffff; // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError

  var SUPPORTS_Y$1 = !_fails$1(function () {
    RegExp(MAX_UINT32$1, "y");
  }); // @@split logic

  _fixReWks$1("split", 2, function (defined, SPLIT, $split, maybeCallNative) {
    var internalSplit;

    if (
      "abbc"[$SPLIT$1](/(b)*/)[1] == "c" ||
      "test"[$SPLIT$1](/(?:)/, -1)[LENGTH$1] != 4 ||
      "ab"[$SPLIT$1](/(?:ab)*/)[LENGTH$1] != 2 ||
      "."[$SPLIT$1](/(.?)(.?)/)[LENGTH$1] != 4 ||
      "."[$SPLIT$1](/()()/)[LENGTH$1] > 1 ||
      ""[$SPLIT$1](/.?/)[LENGTH$1]
    ) {
      // based on es5-shim implementation, need to rework it
      internalSplit = function internalSplit(separator, limit) {
        var string = String(this);
        if (separator === undefined && limit === 0) return []; // If `separator` is not a regex, use native split

        if (!_isRegexp$1(separator))
          return $split.call(string, separator, limit);
        var output = [];
        var flags =
          (separator.ignoreCase ? "i" : "") +
          (separator.multiline ? "m" : "") +
          (separator.unicode ? "u" : "") +
          (separator.sticky ? "y" : "");
        var lastLastIndex = 0;
        var splitLimit = limit === undefined ? MAX_UINT32$1 : limit >>> 0; // Make `global` and avoid `lastIndex` issues by working with a copy

        var separatorCopy = new RegExp(separator.source, flags + "g");
        var match, lastIndex, lastLength;

        while ((match = _regexpExec$1.call(separatorCopy, string))) {
          lastIndex = separatorCopy[LAST_INDEX$2];

          if (lastIndex > lastLastIndex) {
            output.push(string.slice(lastLastIndex, match.index));
            if (match[LENGTH$1] > 1 && match.index < string[LENGTH$1])
              $push$1.apply(output, match.slice(1));
            lastLength = match[0][LENGTH$1];
            lastLastIndex = lastIndex;
            if (output[LENGTH$1] >= splitLimit) break;
          }

          if (separatorCopy[LAST_INDEX$2] === match.index)
            separatorCopy[LAST_INDEX$2]++; // Avoid an infinite loop
        }

        if (lastLastIndex === string[LENGTH$1]) {
          if (lastLength || !separatorCopy.test("")) output.push("");
        } else output.push(string.slice(lastLastIndex));

        return output[LENGTH$1] > splitLimit
          ? output.slice(0, splitLimit)
          : output;
      }; // Chakra, V8
    } else if ("0"[$SPLIT$1](undefined, 0)[LENGTH$1]) {
      internalSplit = function internalSplit(separator, limit) {
        return separator === undefined && limit === 0
          ? []
          : $split.call(this, separator, limit);
      };
    } else {
      internalSplit = $split;
    }

    return [
      // `String.prototype.split` method

      function split(separator, limit) {
        var O = defined(this);
        var splitter = separator == undefined ? undefined : separator[SPLIT];
        return splitter !== undefined
          ? splitter.call(separator, O, limit)
          : internalSplit.call(String(O), separator, limit);
      }, // `RegExp.prototype[@@split]` method

      // NOTE: This cannot be properly polyfilled in engines that don't support
      // the 'y' flag.
      function (regexp, limit) {
        var res = maybeCallNative(
          internalSplit,
          regexp,
          this,
          limit,
          internalSplit !== $split
        );
        if (res.done) return res.value;

        var rx = _anObject$1(regexp);

        var S = String(this);

        var C = _speciesConstructor$1(rx, RegExp);

        var unicodeMatching = rx.unicode;
        var flags =
          (rx.ignoreCase ? "i" : "") +
          (rx.multiline ? "m" : "") +
          (rx.unicode ? "u" : "") +
          (SUPPORTS_Y$1 ? "y" : "g"); // ^(? + rx + ) is needed, in combination with some S slicing, to
        // simulate the 'y' flag.

        var splitter = new C(
          SUPPORTS_Y$1 ? rx : "^(?:" + rx.source + ")",
          flags
        );
        var lim = limit === undefined ? MAX_UINT32$1 : limit >>> 0;
        if (lim === 0) return [];
        if (S.length === 0)
          return _regexpExecAbstract$1(splitter, S) === null ? [S] : [];
        var p = 0;
        var q = 0;
        var A = [];

        while (q < S.length) {
          splitter.lastIndex = SUPPORTS_Y$1 ? q : 0;

          var z = _regexpExecAbstract$1(
            splitter,
            SUPPORTS_Y$1 ? S : S.slice(q)
          );

          var e;

          if (
            z === null ||
            (e = $min$1(
              _toLength$1(splitter.lastIndex + (SUPPORTS_Y$1 ? 0 : q)),
              S.length
            )) === p
          ) {
            q = _advanceStringIndex$1(S, q, unicodeMatching);
          } else {
            A.push(S.slice(p, q));
            if (A.length === lim) return A;

            for (var i = 1; i <= z.length - 1; i++) {
              A.push(z[i]);
              if (A.length === lim) return A;
            }

            q = p = e;
          }
        }

        A.push(S.slice(p));
        return A;
      },
    ];
  });

  var _anInstance$1 = function _anInstance(
    it,
    Constructor,
    name,
    forbiddenField
  ) {
    if (
      !(it instanceof Constructor) ||
      (forbiddenField !== undefined && forbiddenField in it)
    ) {
      throw TypeError(name + ": incorrect invocation!");
    }

    return it;
  };

  var _forOf$1 = createCommonjsModule$1(function (module) {
    var BREAK = {};
    var RETURN = {};

    var exports = (module.exports = function (
      iterable,
      entries,
      fn,
      that,
      ITERATOR
    ) {
      var iterFn = ITERATOR
        ? function () {
            return iterable;
          }
        : core_getIteratorMethod$1(iterable);

      var f = _ctx$1(fn, that, entries ? 2 : 1);

      var index = 0;
      var length, step, iterator, result;
      if (typeof iterFn != "function")
        throw TypeError(iterable + " is not iterable!"); // fast case for arrays with default iterator

      if (_isArrayIter$1(iterFn))
        for (length = _toLength$1(iterable.length); length > index; index++) {
          result = entries
            ? f(_anObject$1((step = iterable[index]))[0], step[1])
            : f(iterable[index]);
          if (result === BREAK || result === RETURN) return result;
        }
      else
        for (
          iterator = iterFn.call(iterable);
          !(step = iterator.next()).done;

        ) {
          result = _iterCall$1(iterator, f, step.value, entries);
          if (result === BREAK || result === RETURN) return result;
        }
    });

    exports.BREAK = BREAK;
    exports.RETURN = RETURN;
  });

  var process$2$1 = _global$1.process;
  var setTask$1 = _global$1.setImmediate;
  var clearTask$1 = _global$1.clearImmediate;
  var MessageChannel$1 = _global$1.MessageChannel;
  var Dispatch$1 = _global$1.Dispatch;
  var counter$1 = 0;
  var queue$1 = {};
  var ONREADYSTATECHANGE$1 = "onreadystatechange";
  var defer$1, channel$1, port$1;

  var run$1 = function run() {
    var id = +this; // eslint-disable-next-line no-prototype-builtins

    if (queue$1.hasOwnProperty(id)) {
      var fn = queue$1[id];
      delete queue$1[id];
      fn();
    }
  };

  var listener$1 = function listener(event) {
    run$1.call(event.data);
  }; // Node.js 0.9+ & IE10+ has setImmediate, otherwise:

  if (!setTask$1 || !clearTask$1) {
    setTask$1 = function setImmediate(fn) {
      var args = [];
      var i = 1;

      while (arguments.length > i) {
        args.push(arguments[i++]);
      }

      queue$1[++counter$1] = function () {
        // eslint-disable-next-line no-new-func
        _invoke$1(typeof fn == "function" ? fn : Function(fn), args);
      };

      defer$1(counter$1);
      return counter$1;
    };

    clearTask$1 = function clearImmediate(id) {
      delete queue$1[id];
    }; // Node.js 0.8-

    if (_cof$1(process$2$1) == "process") {
      defer$1 = function defer(id) {
        process$2$1.nextTick(_ctx$1(run$1, id, 1));
      }; // Sphere (JS game engine) Dispatch API
    } else if (Dispatch$1 && Dispatch$1.now) {
      defer$1 = function defer(id) {
        Dispatch$1.now(_ctx$1(run$1, id, 1));
      }; // Browsers with MessageChannel, includes WebWorkers
    } else if (MessageChannel$1) {
      channel$1 = new MessageChannel$1();
      port$1 = channel$1.port2;
      channel$1.port1.onmessage = listener$1;
      defer$1 = _ctx$1(port$1.postMessage, port$1, 1); // Browsers with postMessage, skip WebWorkers
      // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
    } else if (
      _global$1.addEventListener &&
      typeof postMessage == "function" &&
      !_global$1.importScripts
    ) {
      defer$1 = function defer(id) {
        _global$1.postMessage(id + "", "*");
      };

      _global$1.addEventListener("message", listener$1, false); // IE8-
    } else if (ONREADYSTATECHANGE$1 in _domCreate$1("script")) {
      defer$1 = function defer(id) {
        _html$1.appendChild(_domCreate$1("script"))[ONREADYSTATECHANGE$1] =
          function () {
            _html$1.removeChild(this);

            run$1.call(id);
          };
      }; // Rest old browsers
    } else {
      defer$1 = function defer(id) {
        setTimeout(_ctx$1(run$1, id, 1), 0);
      };
    }
  }

  var _task$1 = {
    set: setTask$1,
    clear: clearTask$1,
  };
  var macrotask$1 = _task$1.set;
  var Observer$1 =
    _global$1.MutationObserver || _global$1.WebKitMutationObserver;
  var process$1$1 = _global$1.process;
  var Promise$1$1 = _global$1.Promise;
  var isNode$1$1 = _cof$1(process$1$1) == "process";

  var _microtask$1 = function _microtask() {
    var head, last, notify;

    var flush = function flush() {
      var parent, fn;
      if (isNode$1$1 && (parent = process$1$1.domain)) parent.exit();

      while (head) {
        fn = head.fn;
        head = head.next;

        try {
          fn();
        } catch (e) {
          if (head) notify();
          else last = undefined;
          throw e;
        }
      }

      last = undefined;
      if (parent) parent.enter();
    }; // Node.js

    if (isNode$1$1) {
      notify = function notify() {
        process$1$1.nextTick(flush);
      }; // browsers with MutationObserver, except iOS Safari -
    } else if (
      Observer$1 &&
      !(_global$1.navigator && _global$1.navigator.standalone)
    ) {
      var toggle = true;
      var node = document.createTextNode("");
      new Observer$1(flush).observe(node, {
        characterData: true,
      }); // eslint-disable-line no-new

      notify = function notify() {
        node.data = toggle = !toggle;
      }; // environments with maybe non-completely correct, but existent Promise
    } else if (Promise$1$1 && Promise$1$1.resolve) {
      // Promise.resolve without an argument throws an error in LG WebOS 2
      var promise = Promise$1$1.resolve(undefined);

      notify = function notify() {
        promise.then(flush);
      }; // for other environments - macrotask based on:
      // - setImmediate
      // - MessageChannel
      // - window.postMessag
      // - onreadystatechange
      // - setTimeout
    } else {
      notify = function notify() {
        // strange IE + webpack dev server bug - use .call(global)
        macrotask$1.call(_global$1, flush);
      };
    }

    return function (fn) {
      var task = {
        fn: fn,
        next: undefined,
      };
      if (last) last.next = task;

      if (!head) {
        head = task;
        notify();
      }

      last = task;
    };
  };

  function PromiseCapability$1(C) {
    var resolve, reject;
    this.promise = new C(function ($$resolve, $$reject) {
      if (resolve !== undefined || reject !== undefined)
        throw TypeError("Bad Promise constructor");
      resolve = $$resolve;
      reject = $$reject;
    });
    this.resolve = _aFunction$1(resolve);
    this.reject = _aFunction$1(reject);
  }

  var f$1$1 = function f$1(C) {
    return new PromiseCapability$1(C);
  };

  var _newPromiseCapability$1 = {
    f: f$1$1,
  };

  var _perform$1 = function _perform(exec) {
    try {
      return {
        e: false,
        v: exec(),
      };
    } catch (e) {
      return {
        e: true,
        v: e,
      };
    }
  };

  var navigator$1 = _global$1.navigator;

  var _userAgent$1 = (navigator$1 && navigator$1.userAgent) || "";

  var _promiseResolve$1 = function _promiseResolve(C, x) {
    _anObject$1(C);

    if (_isObject$1(x) && x.constructor === C) return x;

    var promiseCapability = _newPromiseCapability$1.f(C);

    var resolve = promiseCapability.resolve;
    resolve(x);
    return promiseCapability.promise;
  };

  var _redefineAll$1 = function _redefineAll(target, src, safe) {
    for (var key in src) {
      _redefine$1(target, key, src[key], safe);
    }

    return target;
  };

  var task$1 = _task$1.set;

  var microtask$1 = _microtask$1();

  var PROMISE$1 = "Promise";
  var TypeError$1$1 = _global$1.TypeError;
  var process$3 = _global$1.process;
  var versions$1 = process$3 && process$3.versions;
  var v8$1 = (versions$1 && versions$1.v8) || "";
  var $Promise$1 = _global$1[PROMISE$1];
  var isNode$2 = _classof$1(process$3) == "process";

  var empty$1 = function empty() {
    /* empty */
  };

  var Internal$1,
    newGenericPromiseCapability$1,
    OwnPromiseCapability$1,
    Wrapper$1;
  var newPromiseCapability$1 = (newGenericPromiseCapability$1 =
    _newPromiseCapability$1.f);
  var USE_NATIVE$2 = !!(function () {
    try {
      // correct subclassing with @@species support
      var promise = $Promise$1.resolve(1);

      var FakePromise = ((promise.constructor = {})[_wks$1("species")] =
        function (exec) {
          exec(empty$1, empty$1);
        }); // unhandled rejections tracking support, NodeJS Promise without it fails @@species test

      return (
        (isNode$2 || typeof PromiseRejectionEvent == "function") &&
        promise.then(empty$1) instanceof FakePromise && // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
        // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
        // we can't detect it synchronously, so just check versions
        v8$1.indexOf("6.6") !== 0 &&
        _userAgent$1.indexOf("Chrome/66") === -1
      );
    } catch (e) {
      /* empty */
    }
  })(); // helpers

  var isThenable$1 = function isThenable(it) {
    var then;
    return _isObject$1(it) && typeof (then = it.then) == "function"
      ? then
      : false;
  };

  var notify$1 = function notify(promise, isReject) {
    if (promise._n) return;
    promise._n = true;
    var chain = promise._c;
    microtask$1(function () {
      var value = promise._v;
      var ok = promise._s == 1;
      var i = 0;

      var run = function run(reaction) {
        var handler = ok ? reaction.ok : reaction.fail;
        var resolve = reaction.resolve;
        var reject = reaction.reject;
        var domain = reaction.domain;
        var result, then, exited;

        try {
          if (handler) {
            if (!ok) {
              if (promise._h == 2) onHandleUnhandled$1(promise);
              promise._h = 1;
            }

            if (handler === true) result = value;
            else {
              if (domain) domain.enter();
              result = handler(value); // may throw

              if (domain) {
                domain.exit();
                exited = true;
              }
            }

            if (result === reaction.promise) {
              reject(TypeError$1$1("Promise-chain cycle"));
            } else if ((then = isThenable$1(result))) {
              then.call(result, resolve, reject);
            } else resolve(result);
          } else reject(value);
        } catch (e) {
          if (domain && !exited) domain.exit();
          reject(e);
        }
      };

      while (chain.length > i) {
        run(chain[i++]);
      } // variable length - can't use forEach

      promise._c = [];
      promise._n = false;
      if (isReject && !promise._h) onUnhandled$1(promise);
    });
  };

  var onUnhandled$1 = function onUnhandled(promise) {
    task$1.call(_global$1, function () {
      var value = promise._v;
      var unhandled = isUnhandled$1(promise);
      var result, handler, console;

      if (unhandled) {
        result = _perform$1(function () {
          if (isNode$2) {
            process$3.emit("unhandledRejection", value, promise);
          } else if ((handler = _global$1.onunhandledrejection)) {
            handler({
              promise: promise,
              reason: value,
            });
          } else if ((console = _global$1.console) && console.error) {
            console.error("Unhandled promise rejection", value);
          }
        }); // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should

        promise._h = isNode$2 || isUnhandled$1(promise) ? 2 : 1;
      }

      promise._a = undefined;
      if (unhandled && result.e) throw result.v;
    });
  };

  var isUnhandled$1 = function isUnhandled(promise) {
    return promise._h !== 1 && (promise._a || promise._c).length === 0;
  };

  var onHandleUnhandled$1 = function onHandleUnhandled(promise) {
    task$1.call(_global$1, function () {
      var handler;

      if (isNode$2) {
        process$3.emit("rejectionHandled", promise);
      } else if ((handler = _global$1.onrejectionhandled)) {
        handler({
          promise: promise,
          reason: promise._v,
        });
      }
    });
  };

  var $reject$1 = function $reject(value) {
    var promise = this;
    if (promise._d) return;
    promise._d = true;
    promise = promise._w || promise; // unwrap

    promise._v = value;
    promise._s = 2;
    if (!promise._a) promise._a = promise._c.slice();
    notify$1(promise, true);
  };

  var $resolve$1 = function $resolve(value) {
    var promise = this;
    var then;
    if (promise._d) return;
    promise._d = true;
    promise = promise._w || promise; // unwrap

    try {
      if (promise === value)
        throw TypeError$1$1("Promise can't be resolved itself");

      if ((then = isThenable$1(value))) {
        microtask$1(function () {
          var wrapper = {
            _w: promise,
            _d: false,
          }; // wrap

          try {
            then.call(
              value,
              _ctx$1($resolve, wrapper, 1),
              _ctx$1($reject$1, wrapper, 1)
            );
          } catch (e) {
            $reject$1.call(wrapper, e);
          }
        });
      } else {
        promise._v = value;
        promise._s = 1;
        notify$1(promise, false);
      }
    } catch (e) {
      $reject$1.call(
        {
          _w: promise,
          _d: false,
        },
        e
      ); // wrap
    }
  }; // constructor polyfill

  if (!USE_NATIVE$2) {
    // Promise(executor)
    $Promise$1 = function Promise(executor) {
      _anInstance$1(this, $Promise$1, PROMISE$1, "_h");

      _aFunction$1(executor);

      Internal$1.call(this);

      try {
        executor(_ctx$1($resolve$1, this, 1), _ctx$1($reject$1, this, 1));
      } catch (err) {
        $reject$1.call(this, err);
      }
    }; // eslint-disable-next-line no-unused-vars

    Internal$1 = function Promise(executor) {
      this._c = []; // <- awaiting reactions

      this._a = undefined; // <- checked in isUnhandled reactions

      this._s = 0; // <- state

      this._d = false; // <- done

      this._v = undefined; // <- value

      this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled

      this._n = false; // <- notify
    };

    Internal$1.prototype = _redefineAll$1($Promise$1.prototype, {
      //  Promise.prototype.then(onFulfilled, onRejected)
      then: function then(onFulfilled, onRejected) {
        var reaction = newPromiseCapability$1(
          _speciesConstructor$1(this, $Promise$1)
        );
        reaction.ok = typeof onFulfilled == "function" ? onFulfilled : true;
        reaction.fail = typeof onRejected == "function" && onRejected;
        reaction.domain = isNode$2 ? process$3.domain : undefined;

        this._c.push(reaction);

        if (this._a) this._a.push(reaction);
        if (this._s) notify$1(this, false);
        return reaction.promise;
      },
      //  Promise.prototype.catch(onRejected)
      catch: function _catch(onRejected) {
        return this.then(undefined, onRejected);
      },
    });

    OwnPromiseCapability$1 = function OwnPromiseCapability() {
      var promise = new Internal$1();
      this.promise = promise;
      this.resolve = _ctx$1($resolve$1, promise, 1);
      this.reject = _ctx$1($reject$1, promise, 1);
    };

    _newPromiseCapability$1.f = newPromiseCapability$1 =
      function newPromiseCapability(C) {
        return C === $Promise$1 || C === Wrapper$1
          ? new OwnPromiseCapability$1(C)
          : newGenericPromiseCapability$1(C);
      };
  }

  _export$1(_export$1.G + _export$1.W + _export$1.F * !USE_NATIVE$2, {
    Promise: $Promise$1,
  });

  _setToStringTag$1($Promise$1, PROMISE$1);

  _setSpecies$1(PROMISE$1);

  Wrapper$1 = _core$1[PROMISE$1]; // statics

  _export$1(_export$1.S + _export$1.F * !USE_NATIVE$2, PROMISE$1, {
    //  Promise.reject(r)
    reject: function reject(r) {
      var capability = newPromiseCapability$1(this);
      var $$reject = capability.reject;
      $$reject(r);
      return capability.promise;
    },
  });

  _export$1(_export$1.S + _export$1.F * !USE_NATIVE$2, PROMISE$1, {
    //  Promise.resolve(x)
    resolve: function resolve(x) {
      return _promiseResolve$1(this, x);
    },
  });

  _export$1(
    _export$1.S +
      _export$1.F *
        !(
          USE_NATIVE$2 &&
          _iterDetect$1(function (iter) {
            $Promise$1.all(iter)["catch"](empty$1);
          })
        ),
    PROMISE$1,
    {
      //  Promise.all(iterable)
      all: function all(iterable) {
        var C = this;
        var capability = newPromiseCapability$1(C);
        var resolve = capability.resolve;
        var reject = capability.reject;

        var result = _perform$1(function () {
          var values = [];
          var index = 0;
          var remaining = 1;

          _forOf$1(iterable, false, function (promise) {
            var $index = index++;
            var alreadyCalled = false;
            values.push(undefined);
            remaining++;
            C.resolve(promise).then(function (value) {
              if (alreadyCalled) return;
              alreadyCalled = true;
              values[$index] = value;
              --remaining || resolve(values);
            }, reject);
          });

          --remaining || resolve(values);
        });

        if (result.e) reject(result.v);
        return capability.promise;
      },
      //  Promise.race(iterable)
      race: function race(iterable) {
        var C = this;
        var capability = newPromiseCapability$1(C);
        var reject = capability.reject;

        var result = _perform$1(function () {
          _forOf$1(iterable, false, function (promise) {
            C.resolve(promise).then(capability.resolve, reject);
          });
        });

        if (result.e) reject(result.v);
        return capability.promise;
      },
    }
  );

  var _validateCollection = function _validateCollection(it, TYPE) {
    if (!_isObject$1(it) || it._t !== TYPE)
      throw TypeError("Incompatible receiver, " + TYPE + " required!");
    return it;
  };

  var dP$1$1 = _objectDp$1.f;
  var fastKey = _meta$1.fastKey;
  var SIZE = _descriptors$1 ? "_s" : "size";

  var getEntry = function getEntry(that, key) {
    // fast case
    var index = fastKey(key);
    var entry;
    if (index !== "F") return that._i[index]; // frozen object case

    for (entry = that._f; entry; entry = entry.n) {
      if (entry.k == key) return entry;
    }
  };

  var _collectionStrong = {
    getConstructor: function getConstructor(wrapper, NAME, IS_MAP, ADDER) {
      var C = wrapper(function (that, iterable) {
        _anInstance$1(that, C, NAME, "_i");

        that._t = NAME; // collection type

        that._i = _objectCreate$1(null); // index

        that._f = undefined; // first entry

        that._l = undefined; // last entry

        that[SIZE] = 0; // size

        if (iterable != undefined)
          _forOf$1(iterable, IS_MAP, that[ADDER], that);
      });

      _redefineAll$1(C.prototype, {
        //  Map.prototype.clear()
        //  Set.prototype.clear()
        clear: function clear() {
          for (
            var that = _validateCollection(this, NAME),
              data = that._i,
              entry = that._f;
            entry;
            entry = entry.n
          ) {
            entry.r = true;
            if (entry.p) entry.p = entry.p.n = undefined;
            delete data[entry.i];
          }

          that._f = that._l = undefined;
          that[SIZE] = 0;
        },
        //  Map.prototype.delete(key)
        //  Set.prototype.delete(value)
        delete: function _delete(key) {
          var that = _validateCollection(this, NAME);

          var entry = getEntry(that, key);

          if (entry) {
            var next = entry.n;
            var prev = entry.p;
            delete that._i[entry.i];
            entry.r = true;
            if (prev) prev.n = next;
            if (next) next.p = prev;
            if (that._f == entry) that._f = next;
            if (that._l == entry) that._l = prev;
            that[SIZE]--;
          }

          return !!entry;
        },
        // Set.prototype.forEach(callbackfn, thisArg = undefined)
        // Map.prototype.forEach(callbackfn, thisArg = undefined)
        forEach: function forEach(
          callbackfn
          /* , that = undefined */
        ) {
          _validateCollection(this, NAME);

          var f = _ctx$1(
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined,
            3
          );

          var entry;

          while ((entry = entry ? entry.n : this._f)) {
            f(entry.v, entry.k, this); // revert to the last existing entry

            while (entry && entry.r) {
              entry = entry.p;
            }
          }
        },
        //  Map.prototype.has(key)
        //  Set.prototype.has(value)
        has: function has(key) {
          return !!getEntry(_validateCollection(this, NAME), key);
        },
      });

      if (_descriptors$1)
        dP$1$1(C.prototype, "size", {
          get: function get() {
            return _validateCollection(this, NAME)[SIZE];
          },
        });
      return C;
    },
    def: function def(that, key, value) {
      var entry = getEntry(that, key);
      var prev, index; // change existing entry

      if (entry) {
        entry.v = value; // create new entry
      } else {
        that._l = entry = {
          i: (index = fastKey(key, true)),
          // <- index
          k: key,
          // <- key
          v: value,
          // <- value
          p: (prev = that._l),
          // <- previous entry
          n: undefined,
          // <- next entry
          r: false, // <- removed
        };
        if (!that._f) that._f = entry;
        if (prev) prev.n = entry;
        that[SIZE]++; // add to index

        if (index !== "F") that._i[index] = entry;
      }

      return that;
    },
    getEntry: getEntry,
    setStrong: function setStrong(C, NAME, IS_MAP) {
      // add .keys, .values, .entries, [@@iterator]
      _iterDefine$1(
        C,
        NAME,
        function (iterated, kind) {
          this._t = _validateCollection(iterated, NAME); // target

          this._k = kind; // kind

          this._l = undefined; // previous
        },
        function () {
          var that = this;
          var kind = that._k;
          var entry = that._l; // revert to the last existing entry

          while (entry && entry.r) {
            entry = entry.p;
          } // get next entry

          if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
            // or finish the iteration
            that._t = undefined;
            return _iterStep$1(1);
          } // return step by kind

          if (kind == "keys") return _iterStep$1(0, entry.k);
          if (kind == "values") return _iterStep$1(0, entry.v);
          return _iterStep$1(0, [entry.k, entry.v]);
        },
        IS_MAP ? "entries" : "values",
        !IS_MAP,
        true
      ); // add [@@species],

      _setSpecies$1(NAME);
    },
  };

  var _collection = function _collection(
    NAME,
    wrapper,
    methods,
    common,
    IS_MAP,
    IS_WEAK
  ) {
    var Base = _global$1[NAME];
    var C = Base;
    var ADDER = IS_MAP ? "set" : "add";
    var proto = C && C.prototype;
    var O = {};

    var fixMethod = function fixMethod(KEY) {
      var fn = proto[KEY];

      _redefine$1(
        proto,
        KEY,
        KEY == "delete"
          ? function (a) {
              return IS_WEAK && !_isObject$1(a)
                ? false
                : fn.call(this, a === 0 ? 0 : a);
            }
          : KEY == "has"
          ? function has(a) {
              return IS_WEAK && !_isObject$1(a)
                ? false
                : fn.call(this, a === 0 ? 0 : a);
            }
          : KEY == "get"
          ? function get(a) {
              return IS_WEAK && !_isObject$1(a)
                ? undefined
                : fn.call(this, a === 0 ? 0 : a);
            }
          : KEY == "add"
          ? function add(a) {
              fn.call(this, a === 0 ? 0 : a);
              return this;
            }
          : function set(a, b) {
              fn.call(this, a === 0 ? 0 : a, b);
              return this;
            }
      );
    };

    if (
      typeof C != "function" ||
      !(
        IS_WEAK ||
        (proto.forEach &&
          !_fails$1(function () {
            new C().entries().next();
          }))
      )
    ) {
      // create collection constructor
      C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);

      _redefineAll$1(C.prototype, methods);

      _meta$1.NEED = true;
    } else {
      var instance = new C(); // early implementations not supports chaining

      var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false

      var THROWS_ON_PRIMITIVES = _fails$1(function () {
        instance.has(1);
      }); // most early implementations doesn't supports iterables, most modern - not close it correctly

      var ACCEPT_ITERABLES = _iterDetect$1(function (iter) {
        new C(iter);
      }); // eslint-disable-line no-new
      // for early implementations -0 and +0 not the same

      var BUGGY_ZERO =
        !IS_WEAK &&
        _fails$1(function () {
          // V8 ~ Chromium 42- fails only with 5+ elements
          var $instance = new C();
          var index = 5;

          while (index--) {
            $instance[ADDER](index, index);
          }

          return !$instance.has(-0);
        });

      if (!ACCEPT_ITERABLES) {
        C = wrapper(function (target, iterable) {
          _anInstance$1(target, C, NAME);

          var that = _inheritIfRequired$1(new Base(), target, C);

          if (iterable != undefined)
            _forOf$1(iterable, IS_MAP, that[ADDER], that);
          return that;
        });
        C.prototype = proto;
        proto.constructor = C;
      }

      if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
        fixMethod("delete");
        fixMethod("has");
        IS_MAP && fixMethod("get");
      }

      if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); // weak collections should not contains .clear method

      if (IS_WEAK && proto.clear) delete proto.clear;
    }

    _setToStringTag$1(C, NAME);

    O[NAME] = C;

    _export$1(_export$1.G + _export$1.W + _export$1.F * (C != Base), O);

    if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
    return C;
  };

  var MAP = "Map"; // 23.1 Map Objects

  _collection(
    MAP,
    function (get) {
      return function Map() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    },
    {
      //  Map.prototype.get(key)
      get: function get(key) {
        var entry = _collectionStrong.getEntry(
          _validateCollection(this, MAP),
          key
        );

        return entry && entry.v;
      },
      //  Map.prototype.set(key, value)
      set: function set(key, value) {
        return _collectionStrong.def(
          _validateCollection(this, MAP),
          key === 0 ? 0 : key,
          value
        );
      },
    },
    _collectionStrong,
    true
  );

  var SET = "Set"; // 23.2 Set Objects

  _collection(
    SET,
    function (get) {
      return function Set() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    },
    {
      //  Set.prototype.add(value)
      add: function add(value) {
        return _collectionStrong.def(
          _validateCollection(this, SET),
          (value = value === 0 ? 0 : value),
          value
        );
      },
    },
    _collectionStrong
  );

  var getWeak = _meta$1.getWeak;

  var arrayFind = _arrayMethods$1(5);

  var arrayFindIndex = _arrayMethods$1(6);

  var id$2 = 0; // fallback for uncaught frozen keys

  var uncaughtFrozenStore = function uncaughtFrozenStore(that) {
    return that._l || (that._l = new UncaughtFrozenStore());
  };

  var UncaughtFrozenStore = function UncaughtFrozenStore() {
    this.a = [];
  };

  var findUncaughtFrozen = function findUncaughtFrozen(store, key) {
    return arrayFind(store.a, function (it) {
      return it[0] === key;
    });
  };

  UncaughtFrozenStore.prototype = {
    get: function get(key) {
      var entry = findUncaughtFrozen(this, key);
      if (entry) return entry[1];
    },
    has: function has(key) {
      return !!findUncaughtFrozen(this, key);
    },
    set: function set(key, value) {
      var entry = findUncaughtFrozen(this, key);
      if (entry) entry[1] = value;
      else this.a.push([key, value]);
    },
    delete: function _delete(key) {
      var index = arrayFindIndex(this.a, function (it) {
        return it[0] === key;
      });
      if (~index) this.a.splice(index, 1);
      return !!~index;
    },
  };
  var _collectionWeak = {
    getConstructor: function getConstructor(wrapper, NAME, IS_MAP, ADDER) {
      var C = wrapper(function (that, iterable) {
        _anInstance$1(that, C, NAME, "_i");

        that._t = NAME; // collection type

        that._i = id$2++; // collection id

        that._l = undefined; // leak store for uncaught frozen objects

        if (iterable != undefined)
          _forOf$1(iterable, IS_MAP, that[ADDER], that);
      });

      _redefineAll$1(C.prototype, {
        delete: function _delete(key) {
          if (!_isObject$1(key)) return false;
          var data = getWeak(key);
          if (data === true)
            return uncaughtFrozenStore(_validateCollection(this, NAME))[
              "delete"
            ](key);
          return data && _has$1(data, this._i) && delete data[this._i];
        },
        has: function has(key) {
          if (!_isObject$1(key)) return false;
          var data = getWeak(key);
          if (data === true)
            return uncaughtFrozenStore(_validateCollection(this, NAME)).has(
              key
            );
          return data && _has$1(data, this._i);
        },
      });

      return C;
    },
    def: function def(that, key, value) {
      var data = getWeak(_anObject$1(key), true);
      if (data === true) uncaughtFrozenStore(that).set(key, value);
      else data[that._i] = value;
      return that;
    },
    ufstore: uncaughtFrozenStore,
  };
  createCommonjsModule$1(function (module) {
    var each = _arrayMethods$1(0);

    var NATIVE_WEAK_MAP = _validateCollection;
    var IS_IE11 = !_global$1.ActiveXObject && "ActiveXObject" in _global$1;
    var WEAK_MAP = "WeakMap";
    var getWeak = _meta$1.getWeak;
    var isExtensible = Object.isExtensible;
    var uncaughtFrozenStore = _collectionWeak.ufstore;
    var InternalMap;

    var wrapper = function wrapper(get) {
      return function WeakMap() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    };

    var methods = {
      // WeakMap.prototype.get(key)
      get: function get(key) {
        if (_isObject$1(key)) {
          var data = getWeak(key);
          if (data === true)
            return uncaughtFrozenStore(_validateCollection(this, WEAK_MAP)).get(
              key
            );
          return data ? data[this._i] : undefined;
        }
      },
      // WeakMap.prototype.set(key, value)
      set: function set(key, value) {
        return _collectionWeak.def(
          _validateCollection(this, WEAK_MAP),
          key,
          value
        );
      },
    };

    var $WeakMap = (module.exports = _collection(
      WEAK_MAP,
      wrapper,
      methods,
      _collectionWeak,
      true,
      true
    )); // IE11 WeakMap frozen keys fix

    if (NATIVE_WEAK_MAP && IS_IE11) {
      InternalMap = _collectionWeak.getConstructor(wrapper, WEAK_MAP);

      _objectAssign$1(InternalMap.prototype, methods);

      _meta$1.NEED = true;
      each(["delete", "has", "get", "set"], function (key) {
        var proto = $WeakMap.prototype;
        var method = proto[key];

        _redefine$1(proto, key, function (a, b) {
          // store frozen objects on internal weakmap shim
          if (_isObject$1(a) && !isExtensible(a)) {
            if (!this._f) this._f = new InternalMap();

            var result = this._f[key](a, b);

            return key == "set" ? this : result; // store all the rest on native weakmap
          }

          return method.call(this, a, b);
        });
      });
    }
  });
  var WEAK_SET = "WeakSet"; // 23.4 WeakSet Objects

  _collection(
    WEAK_SET,
    function (get) {
      return function WeakSet() {
        return get(this, arguments.length > 0 ? arguments[0] : undefined);
      };
    },
    {
      //  WeakSet.prototype.add(value)
      add: function add(value) {
        return _collectionWeak.def(
          _validateCollection(this, WEAK_SET),
          value,
          true
        );
      },
    },
    _collectionWeak,
    false,
    true
  );

  var TYPED$1 = _uid$1("typed_array");

  var VIEW$1 = _uid$1("view");

  var ABV$1 = !!(_global$1.ArrayBuffer && _global$1.DataView);
  var CONSTR$1 = ABV$1;
  var i$1$1 = 0;
  var l$1 = 9;
  var Typed$1;
  var TypedArrayConstructors$1 =
    "Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array".split(
      ","
    );

  while (i$1$1 < l$1) {
    if ((Typed$1 = _global$1[TypedArrayConstructors$1[i$1$1++]])) {
      _hide$1(Typed$1.prototype, TYPED$1, true);

      _hide$1(Typed$1.prototype, VIEW$1, true);
    } else CONSTR$1 = false;
  }

  var _typed$1 = {
    ABV: ABV$1,
    CONSTR: CONSTR$1,
    TYPED: TYPED$1,
    VIEW: VIEW$1,
  };

  var _toIndex$1 = function _toIndex(it) {
    if (it === undefined) return 0;

    var number = _toInteger$1(it);

    var length = _toLength$1(number);

    if (number !== length) throw RangeError("Wrong length!");
    return length;
  };

  var _typedBuffer$1 = createCommonjsModule$1(function (module, exports) {
    var gOPN = _objectGopn$1.f;
    var dP = _objectDp$1.f;
    var ARRAY_BUFFER = "ArrayBuffer";
    var DATA_VIEW = "DataView";
    var PROTOTYPE = "prototype";
    var WRONG_LENGTH = "Wrong length!";
    var WRONG_INDEX = "Wrong index!";
    var $ArrayBuffer = _global$1[ARRAY_BUFFER];
    var $DataView = _global$1[DATA_VIEW];
    var Math = _global$1.Math;
    var RangeError = _global$1.RangeError; // eslint-disable-next-line no-shadow-restricted-names

    var Infinity = _global$1.Infinity;
    var BaseBuffer = $ArrayBuffer;
    var abs = Math.abs;
    var pow = Math.pow;
    var floor = Math.floor;
    var log = Math.log;
    var LN2 = Math.LN2;
    var BUFFER = "buffer";
    var BYTE_LENGTH = "byteLength";
    var BYTE_OFFSET = "byteOffset";
    var $BUFFER = _descriptors$1 ? "_b" : BUFFER;
    var $LENGTH = _descriptors$1 ? "_l" : BYTE_LENGTH;
    var $OFFSET = _descriptors$1 ? "_o" : BYTE_OFFSET; // IEEE754 conversions based on

    function packIEEE754(value, mLen, nBytes) {
      var buffer = new Array(nBytes);
      var eLen = nBytes * 8 - mLen - 1;
      var eMax = (1 << eLen) - 1;
      var eBias = eMax >> 1;
      var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0;
      var i = 0;
      var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
      var e, m, c;
      value = abs(value); // eslint-disable-next-line no-self-compare

      if (value != value || value === Infinity) {
        // eslint-disable-next-line no-self-compare
        m = value != value ? 1 : 0;
        e = eMax;
      } else {
        e = floor(log(value) / LN2);

        if (value * (c = pow(2, -e)) < 1) {
          e--;
          c *= 2;
        }

        if (e + eBias >= 1) {
          value += rt / c;
        } else {
          value += rt * pow(2, 1 - eBias);
        }

        if (value * c >= 2) {
          e++;
          c /= 2;
        }

        if (e + eBias >= eMax) {
          m = 0;
          e = eMax;
        } else if (e + eBias >= 1) {
          m = (value * c - 1) * pow(2, mLen);
          e = e + eBias;
        } else {
          m = value * pow(2, eBias - 1) * pow(2, mLen);
          e = 0;
        }
      }

      for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8) {}

      e = (e << mLen) | m;
      eLen += mLen;

      for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8) {}

      buffer[--i] |= s * 128;
      return buffer;
    }

    function unpackIEEE754(buffer, mLen, nBytes) {
      var eLen = nBytes * 8 - mLen - 1;
      var eMax = (1 << eLen) - 1;
      var eBias = eMax >> 1;
      var nBits = eLen - 7;
      var i = nBytes - 1;
      var s = buffer[i--];
      var e = s & 127;
      var m;
      s >>= 7;

      for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8) {}

      m = e & ((1 << -nBits) - 1);
      e >>= -nBits;
      nBits += mLen;

      for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8) {}

      if (e === 0) {
        e = 1 - eBias;
      } else if (e === eMax) {
        return m ? NaN : s ? -Infinity : Infinity;
      } else {
        m = m + pow(2, mLen);
        e = e - eBias;
      }

      return (s ? -1 : 1) * m * pow(2, e - mLen);
    }

    function unpackI32(bytes) {
      return (bytes[3] << 24) | (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
    }

    function packI8(it) {
      return [it & 0xff];
    }

    function packI16(it) {
      return [it & 0xff, (it >> 8) & 0xff];
    }

    function packI32(it) {
      return [
        it & 0xff,
        (it >> 8) & 0xff,
        (it >> 16) & 0xff,
        (it >> 24) & 0xff,
      ];
    }

    function packF64(it) {
      return packIEEE754(it, 52, 8);
    }

    function packF32(it) {
      return packIEEE754(it, 23, 4);
    }

    function addGetter(C, key, internal) {
      dP(C[PROTOTYPE], key, {
        get: function get() {
          return this[internal];
        },
      });
    }

    function get(view, bytes, index, isLittleEndian) {
      var numIndex = +index;

      var intIndex = _toIndex$1(numIndex);

      if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
      var store = view[$BUFFER]._b;
      var start = intIndex + view[$OFFSET];
      var pack = store.slice(start, start + bytes);
      return isLittleEndian ? pack : pack.reverse();
    }

    function set(view, bytes, index, conversion, value, isLittleEndian) {
      var numIndex = +index;

      var intIndex = _toIndex$1(numIndex);

      if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
      var store = view[$BUFFER]._b;
      var start = intIndex + view[$OFFSET];
      var pack = conversion(+value);

      for (var i = 0; i < bytes; i++) {
        store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];
      }
    }

    if (!_typed$1.ABV) {
      $ArrayBuffer = function ArrayBuffer(length) {
        _anInstance$1(this, $ArrayBuffer, ARRAY_BUFFER);

        var byteLength = _toIndex$1(length);

        this._b = _arrayFill$1.call(new Array(byteLength), 0);
        this[$LENGTH] = byteLength;
      };

      $DataView = function DataView(buffer, byteOffset, byteLength) {
        _anInstance$1(this, $DataView, DATA_VIEW);

        _anInstance$1(buffer, $ArrayBuffer, DATA_VIEW);

        var bufferLength = buffer[$LENGTH];

        var offset = _toInteger$1(byteOffset);

        if (offset < 0 || offset > bufferLength)
          throw RangeError("Wrong offset!");
        byteLength =
          byteLength === undefined
            ? bufferLength - offset
            : _toLength$1(byteLength);
        if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
        this[$BUFFER] = buffer;
        this[$OFFSET] = offset;
        this[$LENGTH] = byteLength;
      };

      if (_descriptors$1) {
        addGetter($ArrayBuffer, BYTE_LENGTH, "_l");
        addGetter($DataView, BUFFER, "_b");
        addGetter($DataView, BYTE_LENGTH, "_l");
        addGetter($DataView, BYTE_OFFSET, "_o");
      }

      _redefineAll$1($DataView[PROTOTYPE], {
        getInt8: function getInt8(byteOffset) {
          return (get(this, 1, byteOffset)[0] << 24) >> 24;
        },
        getUint8: function getUint8(byteOffset) {
          return get(this, 1, byteOffset)[0];
        },
        getInt16: function getInt16(
          byteOffset
          /* , littleEndian */
        ) {
          var bytes = get(this, 2, byteOffset, arguments[1]);
          return (((bytes[1] << 8) | bytes[0]) << 16) >> 16;
        },
        getUint16: function getUint16(
          byteOffset
          /* , littleEndian */
        ) {
          var bytes = get(this, 2, byteOffset, arguments[1]);
          return (bytes[1] << 8) | bytes[0];
        },
        getInt32: function getInt32(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackI32(get(this, 4, byteOffset, arguments[1]));
        },
        getUint32: function getUint32(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;
        },
        getFloat32: function getFloat32(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);
        },
        getFloat64: function getFloat64(
          byteOffset
          /* , littleEndian */
        ) {
          return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);
        },
        setInt8: function setInt8(byteOffset, value) {
          set(this, 1, byteOffset, packI8, value);
        },
        setUint8: function setUint8(byteOffset, value) {
          set(this, 1, byteOffset, packI8, value);
        },
        setInt16: function setInt16(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 2, byteOffset, packI16, value, arguments[2]);
        },
        setUint16: function setUint16(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 2, byteOffset, packI16, value, arguments[2]);
        },
        setInt32: function setInt32(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 4, byteOffset, packI32, value, arguments[2]);
        },
        setUint32: function setUint32(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 4, byteOffset, packI32, value, arguments[2]);
        },
        setFloat32: function setFloat32(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 4, byteOffset, packF32, value, arguments[2]);
        },
        setFloat64: function setFloat64(
          byteOffset,
          value
          /* , littleEndian */
        ) {
          set(this, 8, byteOffset, packF64, value, arguments[2]);
        },
      });
    } else {
      if (
        !_fails$1(function () {
          $ArrayBuffer(1);
        }) ||
        !_fails$1(function () {
          new $ArrayBuffer(-1); // eslint-disable-line no-new
        }) ||
        _fails$1(function () {
          new $ArrayBuffer(); // eslint-disable-line no-new

          new $ArrayBuffer(1.5); // eslint-disable-line no-new

          new $ArrayBuffer(NaN); // eslint-disable-line no-new

          return $ArrayBuffer.name != ARRAY_BUFFER;
        })
      ) {
        $ArrayBuffer = function ArrayBuffer(length) {
          _anInstance$1(this, $ArrayBuffer);

          return new BaseBuffer(_toIndex$1(length));
        };

        var ArrayBufferProto = ($ArrayBuffer[PROTOTYPE] =
          BaseBuffer[PROTOTYPE]);

        for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j; ) {
          if (!((key = keys[j++]) in $ArrayBuffer))
            _hide$1($ArrayBuffer, key, BaseBuffer[key]);
        }

        ArrayBufferProto.constructor = $ArrayBuffer;
      } // iOS Safari 7.x bug

      var view = new $DataView(new $ArrayBuffer(2));
      var $setInt8 = $DataView[PROTOTYPE].setInt8;
      view.setInt8(0, 2147483648);
      view.setInt8(1, 2147483649);
      if (view.getInt8(0) || !view.getInt8(1))
        _redefineAll$1(
          $DataView[PROTOTYPE],
          {
            setInt8: function setInt8(byteOffset, value) {
              $setInt8.call(this, byteOffset, (value << 24) >> 24);
            },
            setUint8: function setUint8(byteOffset, value) {
              $setInt8.call(this, byteOffset, (value << 24) >> 24);
            },
          },
          true
        );
    }

    _setToStringTag$1($ArrayBuffer, ARRAY_BUFFER);

    _setToStringTag$1($DataView, DATA_VIEW);

    _hide$1($DataView[PROTOTYPE], _typed$1.VIEW, true);

    exports[ARRAY_BUFFER] = $ArrayBuffer;
    exports[DATA_VIEW] = $DataView;
  });

  var ArrayBuffer = _global$1.ArrayBuffer;
  var $ArrayBuffer = _typedBuffer$1.ArrayBuffer;
  var $DataView = _typedBuffer$1.DataView;
  var $isView = _typed$1.ABV && ArrayBuffer.isView;
  var $slice = $ArrayBuffer.prototype.slice;
  var VIEW$2 = _typed$1.VIEW;
  var ARRAY_BUFFER = "ArrayBuffer";

  _export$1(
    _export$1.G + _export$1.W + _export$1.F * (ArrayBuffer !== $ArrayBuffer),
    {
      ArrayBuffer: $ArrayBuffer,
    }
  );

  _export$1(_export$1.S + _export$1.F * !_typed$1.CONSTR, ARRAY_BUFFER, {
    // ArrayBuffer.isView(arg)
    isView: function isView(it) {
      return ($isView && $isView(it)) || (_isObject$1(it) && VIEW$2 in it);
    },
  });

  _export$1(
    _export$1.P +
      _export$1.U +
      _export$1.F *
        _fails$1(function () {
          return !new $ArrayBuffer(2).slice(1, undefined).byteLength;
        }),
    ARRAY_BUFFER,
    {
      // ArrayBuffer.prototype.slice(start, end)
      slice: function slice(start, end) {
        if ($slice !== undefined && end === undefined)
          return $slice.call(_anObject$1(this), start); // FF fix

        var len = _anObject$1(this).byteLength;

        var first = _toAbsoluteIndex$1(start, len);

        var fin = _toAbsoluteIndex$1(end === undefined ? len : end, len);

        var result = new (_speciesConstructor$1(this, $ArrayBuffer))(
          _toLength$1(fin - first)
        );
        var viewS = new $DataView(this);
        var viewT = new $DataView(result);
        var index = 0;

        while (first < fin) {
          viewT.setUint8(index++, viewS.getUint8(first++));
        }

        return result;
      },
    }
  );

  _setSpecies$1(ARRAY_BUFFER);

  _export$1(_export$1.G + _export$1.W + _export$1.F * !_typed$1.ABV, {
    DataView: _typedBuffer$1.DataView,
  });

  var _typedArray$1 = createCommonjsModule$1(function (module) {
    if (_descriptors$1) {
      var LIBRARY = _library$1;
      var global = _global$1;
      var fails = _fails$1;
      var $export = _export$1;
      var $typed = _typed$1;
      var $buffer = _typedBuffer$1;
      var ctx = _ctx$1;
      var anInstance = _anInstance$1;
      var propertyDesc = _propertyDesc$1;
      var hide = _hide$1;
      var redefineAll = _redefineAll$1;
      var toInteger = _toInteger$1;
      var toLength = _toLength$1;
      var toIndex = _toIndex$1;
      var toAbsoluteIndex = _toAbsoluteIndex$1;
      var toPrimitive = _toPrimitive$1;
      var has = _has$1;
      var classof = _classof$1;
      var isObject = _isObject$1;
      var toObject = _toObject$1;
      var isArrayIter = _isArrayIter$1;
      var create = _objectCreate$1;
      var getPrototypeOf = _objectGpo$1;
      var gOPN = _objectGopn$1.f;
      var getIterFn = core_getIteratorMethod$1;
      var uid = _uid$1;
      var wks = _wks$1;
      var createArrayMethod = _arrayMethods$1;
      var createArrayIncludes = _arrayIncludes$1;
      var speciesConstructor = _speciesConstructor$1;
      var ArrayIterators = es6_array_iterator$1;
      var Iterators = _iterators$1;
      var $iterDetect = _iterDetect$1;
      var setSpecies = _setSpecies$1;
      var arrayFill = _arrayFill$1;
      var arrayCopyWithin = _arrayCopyWithin$1;
      var $DP = _objectDp$1;
      var $GOPD = _objectGopd$1;
      var dP = $DP.f;
      var gOPD = $GOPD.f;
      var RangeError = global.RangeError;
      var TypeError = global.TypeError;
      var Uint8Array = global.Uint8Array;
      var ARRAY_BUFFER = "ArrayBuffer";
      var SHARED_BUFFER = "Shared" + ARRAY_BUFFER;
      var BYTES_PER_ELEMENT = "BYTES_PER_ELEMENT";
      var PROTOTYPE = "prototype";
      var ArrayProto = Array[PROTOTYPE];
      var $ArrayBuffer = $buffer.ArrayBuffer;
      var $DataView = $buffer.DataView;
      var arrayForEach = createArrayMethod(0);
      var arrayFilter = createArrayMethod(2);
      var arraySome = createArrayMethod(3);
      var arrayEvery = createArrayMethod(4);
      var arrayFind = createArrayMethod(5);
      var arrayFindIndex = createArrayMethod(6);
      var arrayIncludes = createArrayIncludes(true);
      var arrayIndexOf = createArrayIncludes(false);
      var arrayValues = ArrayIterators.values;
      var arrayKeys = ArrayIterators.keys;
      var arrayEntries = ArrayIterators.entries;
      var arrayLastIndexOf = ArrayProto.lastIndexOf;
      var arrayReduce = ArrayProto.reduce;
      var arrayReduceRight = ArrayProto.reduceRight;
      var arrayJoin = ArrayProto.join;
      var arraySort = ArrayProto.sort;
      var arraySlice = ArrayProto.slice;
      var arrayToString = ArrayProto.toString;
      var arrayToLocaleString = ArrayProto.toLocaleString;
      var ITERATOR = wks("iterator");
      var TAG = wks("toStringTag");
      var TYPED_CONSTRUCTOR = uid("typed_constructor");
      var DEF_CONSTRUCTOR = uid("def_constructor");
      var ALL_CONSTRUCTORS = $typed.CONSTR;
      var TYPED_ARRAY = $typed.TYPED;
      var VIEW = $typed.VIEW;
      var WRONG_LENGTH = "Wrong length!";
      var $map = createArrayMethod(1, function (O, length) {
        return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
      });
      var LITTLE_ENDIAN = fails(function () {
        // eslint-disable-next-line no-undef
        return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
      });
      var FORCED_SET =
        !!Uint8Array &&
        !!Uint8Array[PROTOTYPE].set &&
        fails(function () {
          new Uint8Array(1).set({});
        });

      var toOffset = function toOffset(it, BYTES) {
        var offset = toInteger(it);
        if (offset < 0 || offset % BYTES) throw RangeError("Wrong offset!");
        return offset;
      };

      var validate = function validate(it) {
        if (isObject(it) && TYPED_ARRAY in it) return it;
        throw TypeError(it + " is not a typed array!");
      };

      var allocate = function allocate(C, length) {
        if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {
          throw TypeError("It is not a typed array constructor!");
        }

        return new C(length);
      };

      var speciesFromList = function speciesFromList(O, list) {
        return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
      };

      var fromList = function fromList(C, list) {
        var index = 0;
        var length = list.length;
        var result = allocate(C, length);

        while (length > index) {
          result[index] = list[index++];
        }

        return result;
      };

      var addGetter = function addGetter(it, key, internal) {
        dP(it, key, {
          get: function get() {
            return this._d[internal];
          },
        });
      };

      var $from = function from(
        source
        /* , mapfn, thisArg */
      ) {
        var O = toObject(source);
        var aLen = arguments.length;
        var mapfn = aLen > 1 ? arguments[1] : undefined;
        var mapping = mapfn !== undefined;
        var iterFn = getIterFn(O);
        var i, length, values, result, step, iterator;

        if (iterFn != undefined && !isArrayIter(iterFn)) {
          for (
            iterator = iterFn.call(O), values = [], i = 0;
            !(step = iterator.next()).done;
            i++
          ) {
            values.push(step.value);
          }

          O = values;
        }

        if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);

        for (
          i = 0, length = toLength(O.length), result = allocate(this, length);
          length > i;
          i++
        ) {
          result[i] = mapping ? mapfn(O[i], i) : O[i];
        }

        return result;
      };

      var $of = function of() /* ...items */
      {
        var index = 0;
        var length = arguments.length;
        var result = allocate(this, length);

        while (length > index) {
          result[index] = arguments[index++];
        }

        return result;
      }; // iOS Safari 6.x fails here

      var TO_LOCALE_BUG =
        !!Uint8Array &&
        fails(function () {
          arrayToLocaleString.call(new Uint8Array(1));
        });

      var $toLocaleString = function toLocaleString() {
        return arrayToLocaleString.apply(
          TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this),
          arguments
        );
      };

      var proto = {
        copyWithin: function copyWithin(
          target,
          start
          /* , end */
        ) {
          return arrayCopyWithin.call(
            validate(this),
            target,
            start,
            arguments.length > 2 ? arguments[2] : undefined
          );
        },
        every: function every(
          callbackfn
          /* , thisArg */
        ) {
          return arrayEvery(
            validate(this),
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        fill: function fill(
          value
          /* , start, end */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayFill.apply(validate(this), arguments);
        },
        filter: function filter(
          callbackfn
          /* , thisArg */
        ) {
          return speciesFromList(
            this,
            arrayFilter(
              validate(this),
              callbackfn,
              arguments.length > 1 ? arguments[1] : undefined
            )
          );
        },
        find: function find(
          predicate
          /* , thisArg */
        ) {
          return arrayFind(
            validate(this),
            predicate,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        findIndex: function findIndex(
          predicate
          /* , thisArg */
        ) {
          return arrayFindIndex(
            validate(this),
            predicate,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        forEach: function forEach(
          callbackfn
          /* , thisArg */
        ) {
          arrayForEach(
            validate(this),
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        indexOf: function indexOf(
          searchElement
          /* , fromIndex */
        ) {
          return arrayIndexOf(
            validate(this),
            searchElement,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        includes: function includes(
          searchElement
          /* , fromIndex */
        ) {
          return arrayIncludes(
            validate(this),
            searchElement,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        join: function join(separator) {
          // eslint-disable-line no-unused-vars
          return arrayJoin.apply(validate(this), arguments);
        },
        lastIndexOf: function lastIndexOf(
          searchElement
          /* , fromIndex */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayLastIndexOf.apply(validate(this), arguments);
        },
        map: function map(
          mapfn
          /* , thisArg */
        ) {
          return $map(
            validate(this),
            mapfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        reduce: function reduce(
          callbackfn
          /* , initialValue */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayReduce.apply(validate(this), arguments);
        },
        reduceRight: function reduceRight(
          callbackfn
          /* , initialValue */
        ) {
          // eslint-disable-line no-unused-vars
          return arrayReduceRight.apply(validate(this), arguments);
        },
        reverse: function reverse() {
          var that = this;
          var length = validate(that).length;
          var middle = Math.floor(length / 2);
          var index = 0;
          var value;

          while (index < middle) {
            value = that[index];
            that[index++] = that[--length];
            that[length] = value;
          }

          return that;
        },
        some: function some(
          callbackfn
          /* , thisArg */
        ) {
          return arraySome(
            validate(this),
            callbackfn,
            arguments.length > 1 ? arguments[1] : undefined
          );
        },
        sort: function sort(comparefn) {
          return arraySort.call(validate(this), comparefn);
        },
        subarray: function subarray(begin, end) {
          var O = validate(this);
          var length = O.length;
          var $begin = toAbsoluteIndex(begin, length);
          return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
            O.buffer,
            O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
            toLength(
              (end === undefined ? length : toAbsoluteIndex(end, length)) -
                $begin
            )
          );
        },
      };

      var $slice = function slice(start, end) {
        return speciesFromList(
          this,
          arraySlice.call(validate(this), start, end)
        );
      };

      var $set = function set(
        arrayLike
        /* , offset */
      ) {
        validate(this);
        var offset = toOffset(arguments[1], 1);
        var length = this.length;
        var src = toObject(arrayLike);
        var len = toLength(src.length);
        var index = 0;
        if (len + offset > length) throw RangeError(WRONG_LENGTH);

        while (index < len) {
          this[offset + index] = src[index++];
        }
      };

      var $iterators = {
        entries: function entries() {
          return arrayEntries.call(validate(this));
        },
        keys: function keys() {
          return arrayKeys.call(validate(this));
        },
        values: function values() {
          return arrayValues.call(validate(this));
        },
      };

      var isTAIndex = function isTAIndex(target, key) {
        return (
          isObject(target) &&
          target[TYPED_ARRAY] &&
          _typeof(key) != "symbol" &&
          key in target &&
          String(+key) == String(key)
        );
      };

      var $getDesc = function getOwnPropertyDescriptor(target, key) {
        return isTAIndex(target, (key = toPrimitive(key, true)))
          ? propertyDesc(2, target[key])
          : gOPD(target, key);
      };

      var $setDesc = function defineProperty(target, key, desc) {
        if (
          isTAIndex(target, (key = toPrimitive(key, true))) &&
          isObject(desc) &&
          has(desc, "value") &&
          !has(desc, "get") &&
          !has(desc, "set") && // TODO: add validation descriptor w/o calling accessors
          !desc.configurable &&
          (!has(desc, "writable") || desc.writable) &&
          (!has(desc, "enumerable") || desc.enumerable)
        ) {
          target[key] = desc.value;
          return target;
        }

        return dP(target, key, desc);
      };

      if (!ALL_CONSTRUCTORS) {
        $GOPD.f = $getDesc;
        $DP.f = $setDesc;
      }

      $export($export.S + $export.F * !ALL_CONSTRUCTORS, "Object", {
        getOwnPropertyDescriptor: $getDesc,
        defineProperty: $setDesc,
      });

      if (
        fails(function () {
          arrayToString.call({});
        })
      ) {
        arrayToString = arrayToLocaleString = function toString() {
          return arrayJoin.call(this);
        };
      }

      var $TypedArrayPrototype$ = redefineAll({}, proto);
      redefineAll($TypedArrayPrototype$, $iterators);
      hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
      redefineAll($TypedArrayPrototype$, {
        slice: $slice,
        set: $set,
        constructor: function constructor() {
          /* noop */
        },
        toString: arrayToString,
        toLocaleString: $toLocaleString,
      });
      addGetter($TypedArrayPrototype$, "buffer", "b");
      addGetter($TypedArrayPrototype$, "byteOffset", "o");
      addGetter($TypedArrayPrototype$, "byteLength", "l");
      addGetter($TypedArrayPrototype$, "length", "e");
      dP($TypedArrayPrototype$, TAG, {
        get: function get() {
          return this[TYPED_ARRAY];
        },
      }); // eslint-disable-next-line max-statements

      module.exports = function (KEY, BYTES, wrapper, CLAMPED) {
        CLAMPED = !!CLAMPED;
        var NAME = KEY + (CLAMPED ? "Clamped" : "") + "Array";
        var GETTER = "get" + KEY;
        var SETTER = "set" + KEY;
        var TypedArray = global[NAME];
        var Base = TypedArray || {};
        var TAC = TypedArray && getPrototypeOf(TypedArray);
        var FORCED = !TypedArray || !$typed.ABV;
        var O = {};
        var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];

        var getter = function getter(that, index) {
          var data = that._d;
          return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
        };

        var setter = function setter(that, index, value) {
          var data = that._d;
          if (CLAMPED)
            value =
              (value = Math.round(value)) < 0
                ? 0
                : value > 0xff
                ? 0xff
                : value & 0xff;
          data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
        };

        var addElement = function addElement(that, index) {
          dP(that, index, {
            get: function get() {
              return getter(this, index);
            },
            set: function set(value) {
              return setter(this, index, value);
            },
            enumerable: true,
          });
        };

        if (FORCED) {
          TypedArray = wrapper(function (that, data, $offset, $length) {
            anInstance(that, TypedArray, NAME, "_d");
            var index = 0;
            var offset = 0;
            var buffer, byteLength, length, klass;

            if (!isObject(data)) {
              length = toIndex(data);
              byteLength = length * BYTES;
              buffer = new $ArrayBuffer(byteLength);
            } else if (
              data instanceof $ArrayBuffer ||
              (klass = classof(data)) == ARRAY_BUFFER ||
              klass == SHARED_BUFFER
            ) {
              buffer = data;
              offset = toOffset($offset, BYTES);
              var $len = data.byteLength;

              if ($length === undefined) {
                if ($len % BYTES) throw RangeError(WRONG_LENGTH);
                byteLength = $len - offset;
                if (byteLength < 0) throw RangeError(WRONG_LENGTH);
              } else {
                byteLength = toLength($length) * BYTES;
                if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);
              }

              length = byteLength / BYTES;
            } else if (TYPED_ARRAY in data) {
              return fromList(TypedArray, data);
            } else {
              return $from.call(TypedArray, data);
            }

            hide(that, "_d", {
              b: buffer,
              o: offset,
              l: byteLength,
              e: length,
              v: new $DataView(buffer),
            });

            while (index < length) {
              addElement(that, index++);
            }
          });
          TypedArrayPrototype = TypedArray[PROTOTYPE] = create(
            $TypedArrayPrototype$
          );
          hide(TypedArrayPrototype, "constructor", TypedArray);
        } else if (
          !fails(function () {
            TypedArray(1);
          }) ||
          !fails(function () {
            new TypedArray(-1); // eslint-disable-line no-new
          }) ||
          !$iterDetect(function (iter) {
            new TypedArray(); // eslint-disable-line no-new

            new TypedArray(null); // eslint-disable-line no-new

            new TypedArray(1.5); // eslint-disable-line no-new

            new TypedArray(iter); // eslint-disable-line no-new
          }, true)
        ) {
          TypedArray = wrapper(function (that, data, $offset, $length) {
            anInstance(that, TypedArray, NAME);
            var klass; // `ws` module bug, temporarily remove validation length for Uint8Array

            if (!isObject(data)) return new Base(toIndex(data));

            if (
              data instanceof $ArrayBuffer ||
              (klass = classof(data)) == ARRAY_BUFFER ||
              klass == SHARED_BUFFER
            ) {
              return $length !== undefined
                ? new Base(data, toOffset($offset, BYTES), $length)
                : $offset !== undefined
                ? new Base(data, toOffset($offset, BYTES))
                : new Base(data);
            }

            if (TYPED_ARRAY in data) return fromList(TypedArray, data);
            return $from.call(TypedArray, data);
          });
          arrayForEach(
            TAC !== Function.prototype
              ? gOPN(Base).concat(gOPN(TAC))
              : gOPN(Base),
            function (key) {
              if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);
            }
          );
          TypedArray[PROTOTYPE] = TypedArrayPrototype;
          if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;
        }

        var $nativeIterator = TypedArrayPrototype[ITERATOR];
        var CORRECT_ITER_NAME =
          !!$nativeIterator &&
          ($nativeIterator.name == "values" ||
            $nativeIterator.name == undefined);
        var $iterator = $iterators.values;
        hide(TypedArray, TYPED_CONSTRUCTOR, true);
        hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
        hide(TypedArrayPrototype, VIEW, true);
        hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);

        if (
          CLAMPED
            ? new TypedArray(1)[TAG] != NAME
            : !(TAG in TypedArrayPrototype)
        ) {
          dP(TypedArrayPrototype, TAG, {
            get: function get() {
              return NAME;
            },
          });
        }

        O[NAME] = TypedArray;
        $export($export.G + $export.W + $export.F * (TypedArray != Base), O);
        $export($export.S, NAME, {
          BYTES_PER_ELEMENT: BYTES,
        });
        $export(
          $export.S +
            $export.F *
              fails(function () {
                Base.of.call(TypedArray, 1);
              }),
          NAME,
          {
            from: $from,
            of: $of,
          }
        );
        if (!(BYTES_PER_ELEMENT in TypedArrayPrototype))
          hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);
        $export($export.P, NAME, proto);
        setSpecies(NAME);
        $export($export.P + $export.F * FORCED_SET, NAME, {
          set: $set,
        });
        $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);
        if (!LIBRARY && TypedArrayPrototype.toString != arrayToString)
          TypedArrayPrototype.toString = arrayToString;
        $export(
          $export.P +
            $export.F *
              fails(function () {
                new TypedArray(1).slice();
              }),
          NAME,
          {
            slice: $slice,
          }
        );
        $export(
          $export.P +
            $export.F *
              (fails(function () {
                return (
                  [1, 2].toLocaleString() !=
                  new TypedArray([1, 2]).toLocaleString()
                );
              }) ||
                !fails(function () {
                  TypedArrayPrototype.toLocaleString.call([1, 2]);
                })),
          NAME,
          {
            toLocaleString: $toLocaleString,
          }
        );
        Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
        if (!LIBRARY && !CORRECT_ITER_NAME)
          hide(TypedArrayPrototype, ITERATOR, $iterator);
      };
    } else
      module.exports = function () {
        /* empty */
      };
  });

  _typedArray$1("Int8", 1, function (init) {
    return function Int8Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1("Uint8", 1, function (init) {
    return function Uint8Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1(
    "Uint8",
    1,
    function (init) {
      return function Uint8ClampedArray(data, byteOffset, length) {
        return init(this, data, byteOffset, length);
      };
    },
    true
  );

  _typedArray$1("Int16", 2, function (init) {
    return function Int16Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1("Uint16", 2, function (init) {
    return function Uint16Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1("Int32", 4, function (init) {
    return function Int32Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1("Uint32", 4, function (init) {
    return function Uint32Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1("Float32", 4, function (init) {
    return function Float32Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  _typedArray$1("Float64", 8, function (init) {
    return function Float64Array(data, byteOffset, length) {
      return init(this, data, byteOffset, length);
    };
  });

  var rApply = (_global$1.Reflect || {}).apply;
  var fApply = Function.apply; // MS Edge argumentsList argument is optional

  _export$1(
    _export$1.S +
      _export$1.F *
        !_fails$1(function () {
          rApply(function () {
            /* empty */
          });
        }),
    "Reflect",
    {
      apply: function apply(target, thisArgument, argumentsList) {
        var T = _aFunction$1(target);

        var L = _anObject$1(argumentsList);

        return rApply
          ? rApply(T, thisArgument, L)
          : fApply.call(T, thisArgument, L);
      },
    }
  );

  var rConstruct = (_global$1.Reflect || {}).construct; // MS Edge supports only 2 arguments and argumentsList argument is optional
  // FF Nightly sets third argument as `new.target`, but does not create `this` from it

  var NEW_TARGET_BUG = _fails$1(function () {
    function F() {
      /* empty */
    }

    return !(
      rConstruct(
        function () {
          /* empty */
        },
        [],
        F
      ) instanceof F
    );
  });

  var ARGS_BUG = !_fails$1(function () {
    rConstruct(function () {
      /* empty */
    });
  });

  _export$1(
    _export$1.S + _export$1.F * (NEW_TARGET_BUG || ARGS_BUG),
    "Reflect",
    {
      construct: function construct(
        Target,
        args
        /* , newTarget */
      ) {
        _aFunction$1(Target);

        _anObject$1(args);

        var newTarget =
          arguments.length < 3 ? Target : _aFunction$1(arguments[2]);
        if (ARGS_BUG && !NEW_TARGET_BUG)
          return rConstruct(Target, args, newTarget);

        if (Target == newTarget) {
          // w/o altered newTarget, optimization for 0-4 arguments
          switch (args.length) {
            case 0:
              return new Target();

            case 1:
              return new Target(args[0]);

            case 2:
              return new Target(args[0], args[1]);

            case 3:
              return new Target(args[0], args[1], args[2]);

            case 4:
              return new Target(args[0], args[1], args[2], args[3]);
          } // w/o altered newTarget, lot of arguments case

          var $args = [null];
          $args.push.apply($args, args);
          return new (_bind$1.apply(Target, $args))();
        } // with altered newTarget, not support built-in constructors

        var proto = newTarget.prototype;

        var instance = _objectCreate$1(
          _isObject$1(proto) ? proto : Object.prototype
        );

        var result = Function.apply.call(Target, instance, args);
        return _isObject$1(result) ? result : instance;
      },
    }
  ); // MS Edge has broken Reflect.defineProperty - throwing instead of returning false

  _export$1(
    _export$1.S +
      _export$1.F *
        _fails$1(function () {
          // eslint-disable-next-line no-undef
          Reflect.defineProperty(
            _objectDp$1.f({}, 1, {
              value: 1,
            }),
            1,
            {
              value: 2,
            }
          );
        }),
    "Reflect",
    {
      defineProperty: function defineProperty(target, propertyKey, attributes) {
        _anObject$1(target);

        propertyKey = _toPrimitive$1(propertyKey, true);

        _anObject$1(attributes);

        try {
          _objectDp$1.f(target, propertyKey, attributes);

          return true;
        } catch (e) {
          return false;
        }
      },
    }
  );

  var gOPD$4 = _objectGopd$1.f;

  _export$1(_export$1.S, "Reflect", {
    deleteProperty: function deleteProperty(target, propertyKey) {
      var desc = gOPD$4(_anObject$1(target), propertyKey);
      return desc && !desc.configurable ? false : delete target[propertyKey];
    },
  });

  var Enumerate = function Enumerate(iterated) {
    this._t = _anObject$1(iterated); // target

    this._i = 0; // next index

    var keys = (this._k = []); // keys

    var key;

    for (key in iterated) {
      keys.push(key);
    }
  };

  _iterCreate$1(Enumerate, "Object", function () {
    var that = this;
    var keys = that._k;
    var key;

    do {
      if (that._i >= keys.length)
        return {
          value: undefined,
          done: true,
        };
    } while (!((key = keys[that._i++]) in that._t));

    return {
      value: key,
      done: false,
    };
  });

  _export$1(_export$1.S, "Reflect", {
    enumerate: function enumerate(target) {
      return new Enumerate(target);
    },
  });

  function get(
    target,
    propertyKey
    /* , receiver */
  ) {
    var receiver = arguments.length < 3 ? target : arguments[2];
    var desc, proto;
    if (_anObject$1(target) === receiver) return target[propertyKey];
    if ((desc = _objectGopd$1.f(target, propertyKey)))
      return _has$1(desc, "value")
        ? desc.value
        : desc.get !== undefined
        ? desc.get.call(receiver)
        : undefined;
    if (_isObject$1((proto = _objectGpo$1(target))))
      return get(proto, propertyKey, receiver);
  }

  _export$1(_export$1.S, "Reflect", {
    get: get,
  });

  _export$1(_export$1.S, "Reflect", {
    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(
      target,
      propertyKey
    ) {
      return _objectGopd$1.f(_anObject$1(target), propertyKey);
    },
  });

  _export$1(_export$1.S, "Reflect", {
    getPrototypeOf: function getPrototypeOf(target) {
      return _objectGpo$1(_anObject$1(target));
    },
  });

  _export$1(_export$1.S, "Reflect", {
    has: function has(target, propertyKey) {
      return propertyKey in target;
    },
  });

  var $isExtensible = Object.isExtensible;

  _export$1(_export$1.S, "Reflect", {
    isExtensible: function isExtensible(target) {
      _anObject$1(target);

      return $isExtensible ? $isExtensible(target) : true;
    },
  });

  var Reflect$1 = _global$1.Reflect;

  var _ownKeys =
    (Reflect$1 && Reflect$1.ownKeys) ||
    function ownKeys(it) {
      var keys = _objectGopn$1.f(_anObject$1(it));

      var getSymbols = _objectGops$1.f;
      return getSymbols ? keys.concat(getSymbols(it)) : keys;
    };

  _export$1(_export$1.S, "Reflect", {
    ownKeys: _ownKeys,
  });

  var $preventExtensions = Object.preventExtensions;

  _export$1(_export$1.S, "Reflect", {
    preventExtensions: function preventExtensions(target) {
      _anObject$1(target);

      try {
        if ($preventExtensions) $preventExtensions(target);
        return true;
      } catch (e) {
        return false;
      }
    },
  });

  function set(
    target,
    propertyKey,
    V
    /* , receiver */
  ) {
    var receiver = arguments.length < 4 ? target : arguments[3];

    var ownDesc = _objectGopd$1.f(_anObject$1(target), propertyKey);

    var existingDescriptor, proto;

    if (!ownDesc) {
      if (_isObject$1((proto = _objectGpo$1(target)))) {
        return set(proto, propertyKey, V, receiver);
      }

      ownDesc = _propertyDesc$1(0);
    }

    if (_has$1(ownDesc, "value")) {
      if (ownDesc.writable === false || !_isObject$1(receiver)) return false;

      if ((existingDescriptor = _objectGopd$1.f(receiver, propertyKey))) {
        if (
          existingDescriptor.get ||
          existingDescriptor.set ||
          existingDescriptor.writable === false
        )
          return false;
        existingDescriptor.value = V;

        _objectDp$1.f(receiver, propertyKey, existingDescriptor);
      } else _objectDp$1.f(receiver, propertyKey, _propertyDesc$1(0, V));

      return true;
    }

    return ownDesc.set === undefined
      ? false
      : (ownDesc.set.call(receiver, V), true);
  }

  _export$1(_export$1.S, "Reflect", {
    set: set,
  });

  if (_setProto$1)
    _export$1(_export$1.S, "Reflect", {
      setPrototypeOf: function setPrototypeOf(target, proto) {
        _setProto$1.check(target, proto);

        try {
          _setProto$1.set(target, proto);

          return true;
        } catch (e) {
          return false;
        }
      },
    });

  var $includes$1 = _arrayIncludes$1(true);

  _export$1(_export$1.P, "Array", {
    includes: function includes(
      el
      /* , fromIndex = 0 */
    ) {
      return $includes$1(
        this,
        el,
        arguments.length > 1 ? arguments[1] : undefined
      );
    },
  });

  _addToUnscopables$1("includes");

  _core$1.Array.includes;

  var IS_CONCAT_SPREADABLE$1 = _wks$1("isConcatSpreadable");

  function flattenIntoArray$1(
    target,
    original,
    source,
    sourceLen,
    start,
    depth,
    mapper,
    thisArg
  ) {
    var targetIndex = start;
    var sourceIndex = 0;
    var mapFn = mapper ? _ctx$1(mapper, thisArg, 3) : false;
    var element, spreadable;

    while (sourceIndex < sourceLen) {
      if (sourceIndex in source) {
        element = mapFn
          ? mapFn(source[sourceIndex], sourceIndex, original)
          : source[sourceIndex];
        spreadable = false;

        if (_isObject$1(element)) {
          spreadable = element[IS_CONCAT_SPREADABLE$1];
          spreadable =
            spreadable !== undefined ? !!spreadable : _isArray$1(element);
        }

        if (spreadable && depth > 0) {
          targetIndex =
            flattenIntoArray$1(
              target,
              original,
              element,
              _toLength$1(element.length),
              targetIndex,
              depth - 1
            ) - 1;
        } else {
          if (targetIndex >= 0x1fffffffffffff) throw TypeError();
          target[targetIndex] = element;
        }

        targetIndex++;
      }

      sourceIndex++;
    }

    return targetIndex;
  }

  var _flattenIntoArray$1 = flattenIntoArray$1;

  _export$1(_export$1.P, "Array", {
    flatMap: function flatMap(
      callbackfn
      /* , thisArg */
    ) {
      var O = _toObject$1(this);

      var sourceLen, A;

      _aFunction$1(callbackfn);

      sourceLen = _toLength$1(O.length);
      A = _arraySpeciesCreate$1(O, 0);

      _flattenIntoArray$1(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]);

      return A;
    },
  });

  _addToUnscopables$1("flatMap");

  _core$1.Array.flatMap;

  var _stringPad$1 = function _stringPad(that, maxLength, fillString, left) {
    var S = String(_defined$1(that));
    var stringLength = S.length;
    var fillStr = fillString === undefined ? " " : String(fillString);

    var intMaxLength = _toLength$1(maxLength);

    if (intMaxLength <= stringLength || fillStr == "") return S;
    var fillLen = intMaxLength - stringLength;

    var stringFiller = _stringRepeat$1.call(
      fillStr,
      Math.ceil(fillLen / fillStr.length)
    );

    if (stringFiller.length > fillLen)
      stringFiller = stringFiller.slice(0, fillLen);
    return left ? stringFiller + S : S + stringFiller;
  };

  var WEBKIT_BUG$1$1 = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(
    _userAgent$1
  );

  _export$1(_export$1.P + _export$1.F * WEBKIT_BUG$1$1, "String", {
    padStart: function padStart(
      maxLength
      /* , fillString = ' ' */
    ) {
      return _stringPad$1(
        this,
        maxLength,
        arguments.length > 1 ? arguments[1] : undefined,
        true
      );
    },
  });

  _core$1.String.padStart;

  var WEBKIT_BUG$2 = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(
    _userAgent$1
  );

  _export$1(_export$1.P + _export$1.F * WEBKIT_BUG$2, "String", {
    padEnd: function padEnd(
      maxLength
      /* , fillString = ' ' */
    ) {
      return _stringPad$1(
        this,
        maxLength,
        arguments.length > 1 ? arguments[1] : undefined,
        false
      );
    },
  });

  _core$1.String.padEnd;

  _stringTrim$1(
    "trimLeft",
    function ($trim) {
      return function trimLeft() {
        return $trim(this, 1);
      };
    },
    "trimStart"
  );

  _core$1.String.trimLeft;

  _stringTrim$1(
    "trimRight",
    function ($trim) {
      return function trimRight() {
        return $trim(this, 2);
      };
    },
    "trimEnd"
  );

  _core$1.String.trimRight;

  _wksDefine$1("asyncIterator");

  _wksExt$1.f("asyncIterator");

  _export$1(_export$1.S, "Object", {
    getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
      var O = _toIobject$1(object);

      var getDesc = _objectGopd$1.f;

      var keys = _ownKeys(O);

      var result = {};
      var i = 0;
      var key, desc;

      while (keys.length > i) {
        desc = getDesc(O, (key = keys[i++]));
        if (desc !== undefined) _createProperty$1(result, key, desc);
      }

      return result;
    },
  });

  _core$1.Object.getOwnPropertyDescriptors;
  var isEnum$2 = _objectPie$1.f;

  var _objectToArray = function _objectToArray(isEntries) {
    return function (it) {
      var O = _toIobject$1(it);

      var keys = _objectKeys$1(O);

      var length = keys.length;
      var i = 0;
      var result = [];
      var key;

      while (length > i) {
        key = keys[i++];

        if (!_descriptors$1 || isEnum$2.call(O, key)) {
          result.push(isEntries ? [key, O[key]] : O[key]);
        }
      }

      return result;
    };
  };

  var $values = _objectToArray(false);

  _export$1(_export$1.S, "Object", {
    values: function values(it) {
      return $values(it);
    },
  });

  _core$1.Object.values;

  var $entries = _objectToArray(true);

  _export$1(_export$1.S, "Object", {
    entries: function entries(it) {
      return $entries(it);
    },
  });

  _core$1.Object.entries;

  _export$1(_export$1.P + _export$1.R, "Promise", {
    finally: function _finally(onFinally) {
      var C = _speciesConstructor$1(this, _core$1.Promise || _global$1.Promise);

      var isFunction = typeof onFinally == "function";
      return this.then(
        isFunction
          ? function (x) {
              return _promiseResolve$1(C, onFinally()).then(function () {
                return x;
              });
            }
          : onFinally,
        isFunction
          ? function (e) {
              return _promiseResolve$1(C, onFinally()).then(function () {
                throw e;
              });
            }
          : onFinally
      );
    },
  });

  _core$1.Promise["finally"];
  var slice = [].slice;
  var MSIE = /MSIE .\./.test(_userAgent$1); // <- dirty ie9- check

  var wrap$2 = function wrap(set) {
    return function (
      fn,
      time
      /* , ...args */
    ) {
      var boundArgs = arguments.length > 2;
      var args = boundArgs ? slice.call(arguments, 2) : false;
      return set(
        boundArgs
          ? function () {
              // eslint-disable-next-line no-new-func
              (typeof fn == "function" ? fn : Function(fn)).apply(this, args);
            }
          : fn,
        time
      );
    };
  };

  _export$1(_export$1.G + _export$1.B + _export$1.F * MSIE, {
    setTimeout: wrap$2(_global$1.setTimeout),
    setInterval: wrap$2(_global$1.setInterval),
  });

  _export$1(_export$1.G + _export$1.B, {
    setImmediate: _task$1.set,
    clearImmediate: _task$1.clear,
  });

  var ITERATOR$5 = _wks$1("iterator");

  var TO_STRING_TAG$1 = _wks$1("toStringTag");

  var ArrayValues$1 = _iterators$1.Array;
  var DOMIterables$1 = {
    CSSRuleList: true,
    // TODO: Not spec compliant, should be false.
    CSSStyleDeclaration: false,
    CSSValueList: false,
    ClientRectList: false,
    DOMRectList: false,
    DOMStringList: false,
    DOMTokenList: true,
    DataTransferItemList: false,
    FileList: false,
    HTMLAllCollection: false,
    HTMLCollection: false,
    HTMLFormElement: false,
    HTMLSelectElement: false,
    MediaList: true,
    // TODO: Not spec compliant, should be false.
    MimeTypeArray: false,
    NamedNodeMap: false,
    NodeList: true,
    PaintRequestList: false,
    Plugin: false,
    PluginArray: false,
    SVGLengthList: false,
    SVGNumberList: false,
    SVGPathSegList: false,
    SVGPointList: false,
    SVGStringList: false,
    SVGTransformList: false,
    SourceBufferList: false,
    StyleSheetList: true,
    // TODO: Not spec compliant, should be false.
    TextTrackCueList: false,
    TextTrackList: false,
    TouchList: false,
  };

  for (
    var collections$1 = _objectKeys$1(DOMIterables$1), i$3 = 0;
    i$3 < collections$1.length;
    i$3++
  ) {
    var NAME$2 = collections$1[i$3];
    var explicit$1 = DOMIterables$1[NAME$2];
    var Collection$1 = _global$1[NAME$2];
    var proto$4 = Collection$1 && Collection$1.prototype;
    var key$2;

    if (proto$4) {
      if (!proto$4[ITERATOR$5]) _hide$1(proto$4, ITERATOR$5, ArrayValues$1);
      if (!proto$4[TO_STRING_TAG$1]) _hide$1(proto$4, TO_STRING_TAG$1, NAME$2);
      _iterators$1[NAME$2] = ArrayValues$1;
      if (explicit$1)
        for (key$2 in es6_array_iterator$1) {
          if (!proto$4[key$2])
            _redefine$1(proto$4, key$2, es6_array_iterator$1[key$2], true);
        }
    }
  }

  createCommonjsModule$1(function (module) {
    /**
     * Copyright (c) 2014-present, Facebook, Inc.
     *
     * This source code is licensed under the MIT license found in the
     * LICENSE file in the root directory of this source tree.
     */
    var runtime = (function (exports) {
      var Op = Object.prototype;
      var hasOwn = Op.hasOwnProperty;
      var undefined$1; // More compressible than void 0.

      var $Symbol = typeof Symbol === "function" ? Symbol : {};
      var iteratorSymbol = $Symbol.iterator || "@@iterator";
      var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
      var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

      function define(obj, key, value) {
        Object.defineProperty(obj, key, {
          value: value,
          enumerable: true,
          configurable: true,
          writable: true,
        });
        return obj[key];
      }

      try {
        // IE 8 has a broken Object.defineProperty that only works on DOM objects.
        define({}, "");
      } catch (err) {
        define = function define(obj, key, value) {
          return (obj[key] = value);
        };
      }

      function wrap(innerFn, outerFn, self, tryLocsList) {
        // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
        var protoGenerator =
          outerFn && outerFn.prototype instanceof Generator
            ? outerFn
            : Generator;
        var generator = Object.create(protoGenerator.prototype);
        var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next,
        // .throw, and .return methods.

        generator._invoke = makeInvokeMethod(innerFn, self, context);
        return generator;
      }

      exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion
      // record like context.tryEntries[i].completion. This interface could
      // have been (and was previously) designed to take a closure to be
      // invoked without arguments, but in all the cases we care about we
      // already have an existing method we want to call, so there's no need
      // to create a new function object. We can even get away with assuming
      // the method takes exactly one argument, since that happens to be true
      // in every case, so we don't have to touch the arguments object. The
      // only additional allocation required is the completion record, which
      // has a stable shape and so hopefully should be cheap to allocate.

      function tryCatch(fn, obj, arg) {
        try {
          return {
            type: "normal",
            arg: fn.call(obj, arg),
          };
        } catch (err) {
          return {
            type: "throw",
            arg: err,
          };
        }
      }

      var GenStateSuspendedStart = "suspendedStart";
      var GenStateSuspendedYield = "suspendedYield";
      var GenStateExecuting = "executing";
      var GenStateCompleted = "completed"; // Returning this object from the innerFn has the same effect as
      // breaking out of the dispatch switch statement.

      var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and
      // .constructor.prototype properties for functions that return Generator
      // objects. For full spec compliance, you may wish to configure your
      // minifier not to mangle the names of these two functions.

      function Generator() {}

      function GeneratorFunction() {}

      function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that
      // don't natively support it.

      var IteratorPrototype = {};

      IteratorPrototype[iteratorSymbol] = function () {
        return this;
      };

      var getProto = Object.getPrototypeOf;
      var NativeIteratorPrototype = getProto && getProto(getProto(values([])));

      if (
        NativeIteratorPrototype &&
        NativeIteratorPrototype !== Op &&
        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)
      ) {
        // This environment has a native %IteratorPrototype%; use it instead
        // of the polyfill.
        IteratorPrototype = NativeIteratorPrototype;
      }

      var Gp =
        (GeneratorFunctionPrototype.prototype =
        Generator.prototype =
          Object.create(IteratorPrototype));
      GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
      GeneratorFunctionPrototype.constructor = GeneratorFunction;
      GeneratorFunction.displayName = define(
        GeneratorFunctionPrototype,
        toStringTagSymbol,
        "GeneratorFunction"
      ); // Helper for defining the .next, .throw, and .return methods of the
      // Iterator interface in terms of a single ._invoke method.

      function defineIteratorMethods(prototype) {
        ["next", "throw", "return"].forEach(function (method) {
          define(prototype, method, function (arg) {
            return this._invoke(method, arg);
          });
        });
      }

      exports.isGeneratorFunction = function (genFun) {
        var ctor = typeof genFun === "function" && genFun.constructor;
        return ctor
          ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can
              // do is to check its .name property.
              (ctor.displayName || ctor.name) === "GeneratorFunction"
          : false;
      };

      exports.mark = function (genFun) {
        if (Object.setPrototypeOf) {
          Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
        } else {
          genFun.__proto__ = GeneratorFunctionPrototype;
          define(genFun, toStringTagSymbol, "GeneratorFunction");
        }

        genFun.prototype = Object.create(Gp);
        return genFun;
      }; // Within the body of any async function, `await x` is transformed to
      // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
      // `hasOwn.call(value, "__await")` to determine if the yielded value is
      // meant to be awaited.

      exports.awrap = function (arg) {
        return {
          __await: arg,
        };
      };

      function AsyncIterator(generator, PromiseImpl) {
        function invoke(method, arg, resolve, reject) {
          var record = tryCatch(generator[method], generator, arg);

          if (record.type === "throw") {
            reject(record.arg);
          } else {
            var result = record.arg;
            var value = result.value;

            if (
              value &&
              _typeof(value) === "object" &&
              hasOwn.call(value, "__await")
            ) {
              return PromiseImpl.resolve(value.__await).then(
                function (value) {
                  invoke("next", value, resolve, reject);
                },
                function (err) {
                  invoke("throw", err, resolve, reject);
                }
              );
            }

            return PromiseImpl.resolve(value).then(
              function (unwrapped) {
                // When a yielded Promise is resolved, its final value becomes
                // the .value of the Promise<{value,done}> result for the
                // current iteration.
                result.value = unwrapped;
                resolve(result);
              },
              function (error) {
                // If a rejected Promise was yielded, throw the rejection back
                // into the async generator function so it can be handled there.
                return invoke("throw", error, resolve, reject);
              }
            );
          }
        }

        var previousPromise;

        function enqueue(method, arg) {
          function callInvokeWithMethodAndArg() {
            return new PromiseImpl(function (resolve, reject) {
              invoke(method, arg, resolve, reject);
            });
          }

          return (previousPromise = // If enqueue has been called before, then we want to wait until
            // all previous Promises have been resolved before calling invoke,
            // so that results are always delivered in the correct order. If
            // enqueue has not been called before, then it is important to
            // call invoke immediately, without waiting on a callback to fire,
            // so that the async generator function has the opportunity to do
            // any necessary setup in a predictable way. This predictability
            // is why the Promise constructor synchronously invokes its
            // executor callback, and why async functions synchronously
            // execute code before the first await. Since we implement simple
            // async functions in terms of async generators, it is especially
            // important to get this right, even though it requires care.
            previousPromise
              ? previousPromise.then(
                  callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later
                  // invocations of the iterator.
                  callInvokeWithMethodAndArg
                )
              : callInvokeWithMethodAndArg());
        } // Define the unified helper method that is used to implement .next,
        // .throw, and .return (see defineIteratorMethods).

        this._invoke = enqueue;
      }

      defineIteratorMethods(AsyncIterator.prototype);

      AsyncIterator.prototype[asyncIteratorSymbol] = function () {
        return this;
      };

      exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of
      // AsyncIterator objects; they just return a Promise for the value of
      // the final result produced by the iterator.

      exports.async = function (
        innerFn,
        outerFn,
        self,
        tryLocsList,
        PromiseImpl
      ) {
        if (PromiseImpl === void 0) PromiseImpl = Promise;
        var iter = new AsyncIterator(
          wrap(innerFn, outerFn, self, tryLocsList),
          PromiseImpl
        );
        return exports.isGeneratorFunction(outerFn)
          ? iter // If outerFn is a generator, return the full iterator.
          : iter.next().then(function (result) {
              return result.done ? result.value : iter.next();
            });
      };

      function makeInvokeMethod(innerFn, self, context) {
        var state = GenStateSuspendedStart;
        return function invoke(method, arg) {
          if (state === GenStateExecuting) {
            throw new Error("Generator is already running");
          }

          if (state === GenStateCompleted) {
            if (method === "throw") {
              throw arg;
            } // Be forgiving, per 25.3.3.3.3 of the spec:
            // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume

            return doneResult();
          }

          context.method = method;
          context.arg = arg;

          while (true) {
            var delegate = context.delegate;

            if (delegate) {
              var delegateResult = maybeInvokeDelegate(delegate, context);

              if (delegateResult) {
                if (delegateResult === ContinueSentinel) continue;
                return delegateResult;
              }
            }

            if (context.method === "next") {
              // Setting context._sent for legacy support of Babel's
              // function.sent implementation.
              context.sent = context._sent = context.arg;
            } else if (context.method === "throw") {
              if (state === GenStateSuspendedStart) {
                state = GenStateCompleted;
                throw context.arg;
              }

              context.dispatchException(context.arg);
            } else if (context.method === "return") {
              context.abrupt("return", context.arg);
            }

            state = GenStateExecuting;
            var record = tryCatch(innerFn, self, context);

            if (record.type === "normal") {
              // If an exception is thrown from innerFn, we leave state ===
              // GenStateExecuting and loop back for another invocation.
              state = context.done ? GenStateCompleted : GenStateSuspendedYield;

              if (record.arg === ContinueSentinel) {
                continue;
              }

              return {
                value: record.arg,
                done: context.done,
              };
            } else if (record.type === "throw") {
              state = GenStateCompleted; // Dispatch the exception by looping back around to the
              // context.dispatchException(context.arg) call above.

              context.method = "throw";
              context.arg = record.arg;
            }
          }
        };
      } // Call delegate.iterator[context.method](context.arg) and handle the
      // result, either by returning a { value, done } result from the
      // delegate iterator, or by modifying context.method and context.arg,
      // setting context.delegate to null, and returning the ContinueSentinel.

      function maybeInvokeDelegate(delegate, context) {
        var method = delegate.iterator[context.method];

        if (method === undefined$1) {
          // A .throw or .return when the delegate iterator has no .throw
          // method always terminates the yield* loop.
          context.delegate = null;

          if (context.method === "throw") {
            // Note: ["return"] must be used for ES3 parsing compatibility.
            if (delegate.iterator["return"]) {
              // If the delegate iterator has a return method, give it a
              // chance to clean up.
              context.method = "return";
              context.arg = undefined$1;
              maybeInvokeDelegate(delegate, context);

              if (context.method === "throw") {
                // If maybeInvokeDelegate(context) changed context.method from
                // "return" to "throw", let that override the TypeError below.
                return ContinueSentinel;
              }
            }

            context.method = "throw";
            context.arg = new TypeError(
              "The iterator does not provide a 'throw' method"
            );
          }

          return ContinueSentinel;
        }

        var record = tryCatch(method, delegate.iterator, context.arg);

        if (record.type === "throw") {
          context.method = "throw";
          context.arg = record.arg;
          context.delegate = null;
          return ContinueSentinel;
        }

        var info = record.arg;

        if (!info) {
          context.method = "throw";
          context.arg = new TypeError("iterator result is not an object");
          context.delegate = null;
          return ContinueSentinel;
        }

        if (info.done) {
          // Assign the result of the finished delegate to the temporary
          // variable specified by delegate.resultName (see delegateYield).
          context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield).

          context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the
          // exception, let the outer generator proceed normally. If
          // context.method was "next", forget context.arg since it has been
          // "consumed" by the delegate iterator. If context.method was
          // "return", allow the original .return call to continue in the
          // outer generator.

          if (context.method !== "return") {
            context.method = "next";
            context.arg = undefined$1;
          }
        } else {
          // Re-yield the result returned by the delegate method.
          return info;
        } // The delegate iterator is finished, so forget it and continue with
        // the outer generator.

        context.delegate = null;
        return ContinueSentinel;
      } // Define Generator.prototype.{next,throw,return} in terms of the
      // unified ._invoke helper method.

      defineIteratorMethods(Gp);
      define(Gp, toStringTagSymbol, "Generator"); // A Generator should always return itself as the iterator object when the
      // @@iterator function is called on it. Some browsers' implementations of the
      // iterator prototype chain incorrectly implement this, causing the Generator
      // object to not be returned from this call. This ensures that doesn't happen.

      Gp[iteratorSymbol] = function () {
        return this;
      };

      Gp.toString = function () {
        return "[object Generator]";
      };

      function pushTryEntry(locs) {
        var entry = {
          tryLoc: locs[0],
        };

        if (1 in locs) {
          entry.catchLoc = locs[1];
        }

        if (2 in locs) {
          entry.finallyLoc = locs[2];
          entry.afterLoc = locs[3];
        }

        this.tryEntries.push(entry);
      }

      function resetTryEntry(entry) {
        var record = entry.completion || {};
        record.type = "normal";
        delete record.arg;
        entry.completion = record;
      }

      function Context(tryLocsList) {
        // The root entry object (effectively a try statement without a catch
        // or a finally block) gives us a place to store values thrown from
        // locations where there is no enclosing try statement.
        this.tryEntries = [
          {
            tryLoc: "root",
          },
        ];
        tryLocsList.forEach(pushTryEntry, this);
        this.reset(true);
      }

      exports.keys = function (object) {
        var keys = [];

        for (var key in object) {
          keys.push(key);
        }

        keys.reverse(); // Rather than returning an object with a next method, we keep
        // things simple and return the next function itself.

        return function next() {
          while (keys.length) {
            var key = keys.pop();

            if (key in object) {
              next.value = key;
              next.done = false;
              return next;
            }
          } // To avoid creating an additional object, we just hang the .value
          // and .done properties off the next function object itself. This
          // also ensures that the minifier will not anonymize the function.

          next.done = true;
          return next;
        };
      };

      function values(iterable) {
        if (iterable) {
          var iteratorMethod = iterable[iteratorSymbol];

          if (iteratorMethod) {
            return iteratorMethod.call(iterable);
          }

          if (typeof iterable.next === "function") {
            return iterable;
          }

          if (!isNaN(iterable.length)) {
            var i = -1,
              next = function next() {
                while (++i < iterable.length) {
                  if (hasOwn.call(iterable, i)) {
                    next.value = iterable[i];
                    next.done = false;
                    return next;
                  }
                }

                next.value = undefined$1;
                next.done = true;
                return next;
              };

            return (next.next = next);
          }
        } // Return an iterator with no values.

        return {
          next: doneResult,
        };
      }

      exports.values = values;

      function doneResult() {
        return {
          value: undefined$1,
          done: true,
        };
      }

      Context.prototype = {
        constructor: Context,
        reset: function reset(skipTempReset) {
          this.prev = 0;
          this.next = 0; // Resetting context._sent for legacy support of Babel's
          // function.sent implementation.

          this.sent = this._sent = undefined$1;
          this.done = false;
          this.delegate = null;
          this.method = "next";
          this.arg = undefined$1;
          this.tryEntries.forEach(resetTryEntry);

          if (!skipTempReset) {
            for (var name in this) {
              // Not sure about the optimal order of these conditions:
              if (
                name.charAt(0) === "t" &&
                hasOwn.call(this, name) &&
                !isNaN(+name.slice(1))
              ) {
                this[name] = undefined$1;
              }
            }
          }
        },
        stop: function stop() {
          this.done = true;
          var rootEntry = this.tryEntries[0];
          var rootRecord = rootEntry.completion;

          if (rootRecord.type === "throw") {
            throw rootRecord.arg;
          }

          return this.rval;
        },
        dispatchException: function dispatchException(exception) {
          if (this.done) {
            throw exception;
          }

          var context = this;

          function handle(loc, caught) {
            record.type = "throw";
            record.arg = exception;
            context.next = loc;

            if (caught) {
              // If the dispatched exception was caught by a catch block,
              // then let that catch block handle the exception normally.
              context.method = "next";
              context.arg = undefined$1;
            }

            return !!caught;
          }

          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];
            var record = entry.completion;

            if (entry.tryLoc === "root") {
              // Exception thrown outside of any try block that could handle
              // it, so set the completion value of the entire function to
              // throw the exception.
              return handle("end");
            }

            if (entry.tryLoc <= this.prev) {
              var hasCatch = hasOwn.call(entry, "catchLoc");
              var hasFinally = hasOwn.call(entry, "finallyLoc");

              if (hasCatch && hasFinally) {
                if (this.prev < entry.catchLoc) {
                  return handle(entry.catchLoc, true);
                } else if (this.prev < entry.finallyLoc) {
                  return handle(entry.finallyLoc);
                }
              } else if (hasCatch) {
                if (this.prev < entry.catchLoc) {
                  return handle(entry.catchLoc, true);
                }
              } else if (hasFinally) {
                if (this.prev < entry.finallyLoc) {
                  return handle(entry.finallyLoc);
                }
              } else {
                throw new Error("try statement without catch or finally");
              }
            }
          }
        },
        abrupt: function abrupt(type, arg) {
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];

            if (
              entry.tryLoc <= this.prev &&
              hasOwn.call(entry, "finallyLoc") &&
              this.prev < entry.finallyLoc
            ) {
              var finallyEntry = entry;
              break;
            }
          }

          if (
            finallyEntry &&
            (type === "break" || type === "continue") &&
            finallyEntry.tryLoc <= arg &&
            arg <= finallyEntry.finallyLoc
          ) {
            // Ignore the finally entry if control is not jumping to a
            // location outside the try/catch block.
            finallyEntry = null;
          }

          var record = finallyEntry ? finallyEntry.completion : {};
          record.type = type;
          record.arg = arg;

          if (finallyEntry) {
            this.method = "next";
            this.next = finallyEntry.finallyLoc;
            return ContinueSentinel;
          }

          return this.complete(record);
        },
        complete: function complete(record, afterLoc) {
          if (record.type === "throw") {
            throw record.arg;
          }

          if (record.type === "break" || record.type === "continue") {
            this.next = record.arg;
          } else if (record.type === "return") {
            this.rval = this.arg = record.arg;
            this.method = "return";
            this.next = "end";
          } else if (record.type === "normal" && afterLoc) {
            this.next = afterLoc;
          }

          return ContinueSentinel;
        },
        finish: function finish(finallyLoc) {
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];

            if (entry.finallyLoc === finallyLoc) {
              this.complete(entry.completion, entry.afterLoc);
              resetTryEntry(entry);
              return ContinueSentinel;
            }
          }
        },
        catch: function _catch(tryLoc) {
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];

            if (entry.tryLoc === tryLoc) {
              var record = entry.completion;

              if (record.type === "throw") {
                var thrown = record.arg;
                resetTryEntry(entry);
              }

              return thrown;
            }
          } // The context.catch method must only be called with a location
          // argument that corresponds to a known catch block.

          throw new Error("illegal catch attempt");
        },
        delegateYield: function delegateYield(iterable, resultName, nextLoc) {
          this.delegate = {
            iterator: values(iterable),
            resultName: resultName,
            nextLoc: nextLoc,
          };

          if (this.method === "next") {
            // Deliberately forget the last sent value so that we don't
            // accidentally pass it on to the delegate.
            this.arg = undefined$1;
          }

          return ContinueSentinel;
        },
      }; // Regardless of whether this script is executing as a CommonJS module
      // or not, return the runtime object so that we can declare the variable
      // regeneratorRuntime in the outer scope, which allows this module to be
      // injected easily by `bin/regenerator --include-runtime script.js`.

      return exports;
    })(
      // If this script is executing as a CommonJS module, use module.exports
      // as the regeneratorRuntime namespace. Otherwise create a new empty
      // object. Either way, the resulting object will be used to initialize
      // the regeneratorRuntime variable at the top of this file.
      module.exports
    );

    try {
      regeneratorRuntime = runtime;
    } catch (accidentalStrictMode) {
      // This module should not be running in strict mode, so the above
      // assignment should always work unless something is misconfigured. Just
      // in case runtime.js accidentally runs in strict mode, we can escape
      // strict mode using a global Function call. This could conceivably fail
      // if a Content Security Policy forbids using Function, but in that case
      // the proper solution is to fix the accidental strict mode problem. If
      // you've misconfigured your bundler to force strict mode and applied a
      // CSP to forbid Function, and you're not willing to fix either of those
      // problems, please detail your unique predicament in a GitHub issue.
      Function("r", "regeneratorRuntime = r")(runtime);
    }
  });

  var _global$2 = createCommonjsModule$1(function (module) {
    var global = (module.exports =
      typeof window != "undefined" && window.Math == Math
        ? window
        : typeof self != "undefined" && self.Math == Math
        ? self // eslint-disable-next-line no-new-func
        : Function("return this")());
    if (typeof __g == "number") __g = global; // eslint-disable-line no-undef
  });

  var _core$2 = createCommonjsModule$1(function (module) {
    var core = (module.exports = {
      version: "2.6.12",
    });
    if (typeof __e == "number") __e = core; // eslint-disable-line no-undef
  });

  _core$2.version;

  var _aFunction$2 = function _aFunction(it) {
    if (typeof it != "function") throw TypeError(it + " is not a function!");
    return it;
  };

  var _ctx$2 = function _ctx(fn, that, length) {
    _aFunction$2(fn);

    if (that === undefined) return fn;

    switch (length) {
      case 1:
        return function (a) {
          return fn.call(that, a);
        };

      case 2:
        return function (a, b) {
          return fn.call(that, a, b);
        };

      case 3:
        return function (a, b, c) {
          return fn.call(that, a, b, c);
        };
    }

    return function () /* ...args */
    {
      return fn.apply(that, arguments);
    };
  };

  var _isObject$2 = function _isObject(it) {
    return _typeof(it) === "object" ? it !== null : typeof it === "function";
  };

  var _anObject$2 = function _anObject(it) {
    if (!_isObject$2(it)) throw TypeError(it + " is not an object!");
    return it;
  };

  var _fails$2 = function _fails(exec) {
    try {
      return !!exec();
    } catch (e) {
      return true;
    }
  };

  var _descriptors$2 = !_fails$2(function () {
    return (
      Object.defineProperty({}, "a", {
        get: function get() {
          return 7;
        },
      }).a != 7
    );
  });

  var document$1$1 = _global$2.document; // typeof document.createElement is 'object' in old IE

  var is$2 =
    _isObject$2(document$1$1) && _isObject$2(document$1$1.createElement);

  var _domCreate$2 = function _domCreate(it) {
    return is$2 ? document$1$1.createElement(it) : {};
  };

  var _ie8DomDefine$2 =
    !_descriptors$2 &&
    !_fails$2(function () {
      return (
        Object.defineProperty(_domCreate$2("div"), "a", {
          get: function get() {
            return 7;
          },
        }).a != 7
      );
    }); // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string

  var _toPrimitive$2 = function _toPrimitive(it, S) {
    if (!_isObject$2(it)) return it;
    var fn, val;
    if (
      S &&
      typeof (fn = it.toString) == "function" &&
      !_isObject$2((val = fn.call(it)))
    )
      return val;
    if (
      typeof (fn = it.valueOf) == "function" &&
      !_isObject$2((val = fn.call(it)))
    )
      return val;
    if (
      !S &&
      typeof (fn = it.toString) == "function" &&
      !_isObject$2((val = fn.call(it)))
    )
      return val;
    throw TypeError("Can't convert object to primitive value");
  };

  var dP$7 = Object.defineProperty;
  var f$9 = _descriptors$2
    ? Object.defineProperty
    : function defineProperty(O, P, Attributes) {
        _anObject$2(O);

        P = _toPrimitive$2(P, true);

        _anObject$2(Attributes);

        if (_ie8DomDefine$2)
          try {
            return dP$7(O, P, Attributes);
          } catch (e) {
            /* empty */
          }
        if ("get" in Attributes || "set" in Attributes)
          throw TypeError("Accessors not supported!");
        if ("value" in Attributes) O[P] = Attributes.value;
        return O;
      };
  var _objectDp$2 = {
    f: f$9,
  };

  var _propertyDesc$2 = function _propertyDesc(bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value,
    };
  };

  var _hide$2 = _descriptors$2
    ? function (object, key, value) {
        return _objectDp$2.f(object, key, _propertyDesc$2(1, value));
      }
    : function (object, key, value) {
        object[key] = value;
        return object;
      };

  var hasOwnProperty$2 = {}.hasOwnProperty;

  var _has$2 = function _has(it, key) {
    return hasOwnProperty$2.call(it, key);
  };

  var PROTOTYPE$4 = "prototype";

  var $export$2 = function $export(type, name, source) {
    var IS_FORCED = type & $export.F;
    var IS_GLOBAL = type & $export.G;
    var IS_STATIC = type & $export.S;
    var IS_PROTO = type & $export.P;
    var IS_BIND = type & $export.B;
    var IS_WRAP = type & $export.W;
    var exports = IS_GLOBAL ? _core$2 : _core$2[name] || (_core$2[name] = {});
    var expProto = exports[PROTOTYPE$4];
    var target = IS_GLOBAL
      ? _global$2
      : IS_STATIC
      ? _global$2[name]
      : (_global$2[name] || {})[PROTOTYPE$4];
    var key, own, out;
    if (IS_GLOBAL) source = name;

    for (key in source) {
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined;
      if (own && _has$2(exports, key)) continue; // export native or passed

      out = own ? target[key] : source[key]; // prevent global pollution for namespaces

      exports[key] =
        IS_GLOBAL && typeof target[key] != "function"
          ? source[key] // bind timers to global for call from export context
          : IS_BIND && own
          ? _ctx$2(out, _global$2) // wrap global constructors for prevent change them in library
          : IS_WRAP && target[key] == out
          ? (function (C) {
              var F = function F(a, b, c) {
                if (this instanceof C) {
                  switch (arguments.length) {
                    case 0:
                      return new C();

                    case 1:
                      return new C(a);

                    case 2:
                      return new C(a, b);
                  }

                  return new C(a, b, c);
                }

                return C.apply(this, arguments);
              };

              F[PROTOTYPE$4] = C[PROTOTYPE$4];
              return F; // make static versions for prototype methods
            })(out)
          : IS_PROTO && typeof out == "function"
          ? _ctx$2(Function.call, out)
          : out; // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%

      if (IS_PROTO) {
        (exports.virtual || (exports.virtual = {}))[key] = out; // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%

        if (type & $export.R && expProto && !expProto[key])
          _hide$2(expProto, key, out);
      }
    }
  }; // type bitmap

  $export$2.F = 1; // forced

  $export$2.G = 2; // global

  $export$2.S = 4; // static

  $export$2.P = 8; // proto

  $export$2.B = 16; // bind

  $export$2.W = 32; // wrap

  $export$2.U = 64; // safe

  $export$2.R = 128; // real proto method for `library`

  var _export$2 = $export$2;

  _export$2(_export$2.G, {
    global: _global$2,
  });

  _core$2.global;
  var global = _core$2.global;
  var D__code_gwm_node_modules__babel_polyfill_lib = createCommonjsModule$1(
    function (module) {
      var _global = _interopRequireDefault(global);

      function _interopRequireDefault(obj) {
        return obj && obj.__esModule
          ? obj
          : {
              default: obj,
            };
      }

      if (
        _global["default"]._babelPolyfill &&
        typeof console !== "undefined" &&
        console.warn
      ) {
        console.warn(
          "@babel/polyfill is loaded more than once on this page. This is probably not desirable/intended " +
            "and may have consequences if different versions of the polyfills are applied sequentially. " +
            "If you do need to load the polyfill more than once, use @babel/polyfill/noConflict " +
            "instead to bypass the warning."
        );
      }

      _global["default"]._babelPolyfill = true;
    }
  );
  unwrapExports(D__code_gwm_node_modules__babel_polyfill_lib);

  var Watermark =
    /** @class */
    (function () {
      function Watermark(_a) {
        var _b = _a.txt,
          txt =
            _b === void 0
              ? new Date().toLocaleDateString() + " Top secret"
              : _b,
          _c = _a.x,
          x = _c === void 0 ? 0 : _c,
          _d = _a.y,
          y = _d === void 0 ? 50 : _d,
          _e = _a.font,
          font = _e === void 0 ? "microsoft yahe" : _e,
          _f = _a.color,
          color = _f === void 0 ? "#000" : _f,
          _g = _a.fontSize,
          fontSize = _g === void 0 ? 12 : _g,
          _h = _a.alpha,
          alpha = _h === void 0 ? 0.1 : _h,
          _j = _a.width,
          width = _j === void 0 ? 158 : _j,
          _k = _a.height,
          height = _k === void 0 ? 100 : _k,
          _l = _a.angle,
          angle = _l === void 0 ? -15 : _l;
        this.txt = txt;
        this.width = width;
        this.height = height;
        this.x = x;
        this.y = y;
        this.font = font;
        this.fontSize = fontSize;
        this.color = color;
        this.alpha = alpha;
        this.angle = angle;
      }

      return Watermark;
    })();

  var SvgWay =
    /** @class */
    (function () {
      function SvgWay(watermark) {
        this.watermark = watermark;
      }

      SvgWay.prototype.render = function () {
        var _a = this.watermark,
          txt = _a.txt,
          x = _a.x,
          y = _a.y,
          width = _a.width,
          height = _a.height,
          color = _a.color,
          font = _a.font,
          fontSize = _a.fontSize,
          alpha = _a.alpha,
          angle = _a.angle;
        var svgStr =
          '<svg xmlns="http://www.w3.org/2000/svg" width="' +
          width +
          'px" height="' +
          height +
          'px">\n                <text x="' +
          x +
          'px" y="' +
          y +
          'px" dy="' +
          fontSize +
          'px"\n                    text-anchor="start"\n                    stroke="' +
          color +
          '"\n                    stroke-opacity="' +
          alpha +
          '"\n                    fill="none"\n                    transform="rotate(' +
          angle +
          "," +
          x +
          " " +
          y +
          ')"\n                    font-weight="100"\n                    font-size="' +
          fontSize +
          '"\n                    font-family="' +
          font +
          '"\n                    >\n                    ' +
          txt +
          "\n                </text>\n            </svg>";
        return (
          "data:image/svg+xml;base64," +
          window.btoa(unescape(encodeURIComponent(svgStr)))
        );
      };

      return SvgWay;
    })();

  var CanvasWay =
    /** @class */
    (function () {
      function CanvasWay(watermark) {
        this.watermark = watermark;
        var width = watermark.width,
          height = watermark.height;
        this.canvas = document.createElement("canvas");
        this.canvas.setAttribute("width", "" + width);
        this.canvas.setAttribute("height", "" + height);
      }

      CanvasWay.prototype.render = function () {
        var _a = this.watermark,
          txt = _a.txt,
          x = _a.x,
          y = _a.y,
          width = _a.width,
          height = _a.height,
          font = _a.font,
          color = _a.color,
          fontSize = _a.fontSize,
          alpha = _a.alpha,
          angle = _a.angle;
        var ctx = this.canvas.getContext("2d");

        if (ctx === null) {
          throw new Error("getContext error");
        }

        ctx.clearRect(0, 0, width, height);
        ctx.textBaseline = "top";
        ctx.textAlign = "left";
        ctx.fillStyle = color;
        ctx.globalAlpha = alpha;
        ctx.font = fontSize + "px " + font;
        ctx.translate(x, y);
        ctx.rotate((Math.PI / 180) * angle);
        ctx.translate(-x, -y - fontSize);
        ctx.fillText(txt, x, y + fontSize);
        return this.canvas.toDataURL();
      };

      return CanvasWay;
    })();
  /*! *****************************************************************************
	Copyright (c) Microsoft Corporation. All rights reserved.
	Licensed under the Apache License, Version 2.0 (the "License"); you may not use
	this file except in compliance with the License. You may obtain a copy of the
	License at

	THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
	WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
	MERCHANTABLITY OR NON-INFRINGEMENT.

	See the Apache Version 2.0 License for specific language governing permissions
	and limitations under the License.
	***************************************************************************** */

  function __spreadArrays() {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) {
      s += arguments[i].length;
    }

    for (var r = Array(s), k = 0, i = 0; i < il; i++) {
      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) {
        r[k] = a[j];
      }
    }

    return r;
  }

  var humpToLine = function humpToLine(name) {
    return name.replace(/([A-Z])/g, "_$1").toLowerCase();
  };

  var isSupport = function isSupport(attribute) {
    return attribute in document.documentElement.style;
  };

  var assignStyle = function assignStyle() {
    var args = [];

    for (var _i = 0; _i < arguments.length; _i++) {
      args[_i] = arguments[_i];
    }

    var _a = args.filter(function (item) {
        return item;
      }),
      oldStyle = _a[0],
      newStyles = _a.slice(1);

    return Object.assign.apply(null, __spreadArrays([oldStyle], newStyles));
  };

  var bindCSS = function bindCSS(elem, css, priority) {
    var mergeStyle = assignStyle(elem.style, css);

    for (var key in mergeStyle) {
      if (mergeStyle.hasOwnProperty(key)) {
        if (priority === "normal") {
          elem.style[key] = mergeStyle[key];
          continue;
        }

        if (elem.style.setProperty) {
          elem.style.setProperty(key, css[key], "important");
          continue;
        }

        var oldStyle = elem.getAttribute("style");
        var newStyle = [humpToLine(key), css[key] + "!important;"].join(":");
        elem.setAttribute("style", [oldStyle, newStyle].join(" ").trim());
      }
    }

    return elem;
  };

  var ElementWay =
    /** @class */
    (function () {
      function ElementWay(watermark) {
        this.watermark = watermark;
      }

      ElementWay.prototype.createItem = function () {
        var _a = this.watermark,
          txt = _a.txt,
          x = _a.x,
          y = _a.y,
          font = _a.font,
          color = _a.color,
          fontSize = _a.fontSize,
          alpha = _a.alpha,
          angle = _a.angle,
          width = _a.width,
          height = _a.height;
        var item = document.createElement("div");
        bindCSS(
          item,
          Object.create({
            position: "relative",
            width: width + "px",
            height: height + "px",
            flex: "0 0 " + width + "px",
            overflow: "hidden",
            pointerEvents: "none",
          }),
          "normal"
        );
        var span = document.createElement("span");
        span.innerHTML = txt;
        bindCSS(
          span,
          Object.create({
            position: "absolute",
            top: y + "px",
            left: x + "px",
            fontFamily: font,
            fontSize: fontSize + "px",
            color: color,
            lineHeight: 1.5,
            opacity: alpha,
            fontWeight: 400,
            transform: "rotate(" + angle + "deg)",
            transformOrigin: "0 0",
            userSelect: "none",
            whiteSpace: "nowrap",
            overflow: "hidden",
          }),
          "normal"
        );
        item.appendChild(span);
        return item;
      };

      ElementWay.prototype.render = function () {
        var i = 0;
        var _a = this.watermark,
          width = _a.width,
          height = _a.height;

        var _b = document.documentElement || document.body,
          clientWidth = _b.clientWidth,
          clientHeight = _b.clientHeight;

        var column = Math.ceil(clientWidth / width);
        var rows = Math.ceil(clientHeight / height);
        var wrap = document.createElement("div");
        bindCSS(
          wrap,
          Object.create({
            display: "flex",
            flexWrap: "wrap",
            width: width * column + "px",
            height: height * rows + "px",
          }),
          "normal"
        );

        for (; i < column * rows; i++) {
          wrap.appendChild(this.createItem());
        }

        return wrap;
      };

      return ElementWay;
    })();

  var mutationObserver =
    MutationObserver || WebKitMutationObserver || MozMutationObserver;

  function bindMutationEvent(target, container, callback) {
    var eventList = [
      "DOMAttrModified",
      "DOMAttributeNameChanged",
      "DOMCharacterDataModified",
      "DOMElementNameChanged",
      "DOMNodeInserted",
      "DOMNodeInsertedIntoDocument",
      "DOMNodeRemoved",
      "DOMNodeRemovedFromDocument",
      "DOMSubtreeModified",
    ];
    eventList.map(function (eventName) {
      return target.addEventListener(
        eventName,
        function () {
          return callback();
        },
        false
      );
    });
    document.body.addEventListener(
      "DOMSubtreeModified",
      function () {
        return callback();
      },
      false
    );
    return {
      containerObserver: {
        disconnect: function disconnect() {
          return container.removeEventListener(
            "DOMSubtreeModified",
            function () {
              return callback();
            },
            false
          );
        },
      },
      targetObserver: {
        disconnect: function disconnect() {
          return eventList.map(function (eventName) {
            return target.removeEventListener(
              eventName,
              function () {
                return callback();
              },
              false
            );
          });
        },
      },
    };
  }

  var observer = function observer(target, container, callback) {
    if (!mutationObserver) {
      return bindMutationEvent(target, container, callback);
    }

    var containerObserver = new mutationObserver(function (mutationsList) {
      //        mutationsList.forEach(function (mutation) {
      //            mutation.removedNodes.forEach(function (item) {
      //                if (item === target) {
      //                    callback();
      //                }
      //            });
      //        });
      for (var _i2 in mutationsList) {
        var item0 = mutationsList[_i2];

        for (var _j2 in item0.removeNodes) {
          var item = item0.removeNodes[_j2];

          if (item === target) {
            callback();
          }
        } //            try{
        //                        if(gwmDom){
        //                           gwmDom.remove()
        //                        }
        //                      }catch(e){
        //                            if(gwmDom){
        //                                gwmDom.removeNode(true);
        //                            }
        //                      }
        //            }
      }
    });
    containerObserver.observe(container, {
      childList: true,
    });
    var targetObserver = new MutationObserver(callback);
    targetObserver.observe(target, {
      characterData: true,
      attributes: true,
      childList: true,
      subtree: true,
    });
    return {
      containerObserver: containerObserver,
      targetObserver: targetObserver,
    };
  };

  var disconnect = function disconnect(currentObserver) {
    var containerObserver = currentObserver.containerObserver,
      targetObserver = currentObserver.targetObserver;
    containerObserver.disconnect();
    targetObserver.disconnect();
  };

  var creator = function creator(gwm) {
    var gwmDom = gwm.gwmDom;
    var css = Object.create(gwm.opts.css); //    if (gwmDom) {
    //        gwmDom.remove();
    //    }

    try {
      if (gwmDom) {
        gwmDom.remove();
      }
    } catch (e) {
      if (gwmDom) {
        gwmDom.removeNode(true);
      }
    }

    var gwmDiv = document.createElement("div");

    if (isSupport("pointerEvents")) {
      css.pointerEvents = "none";
      css.zIndex = parseInt("" + css.zIndex, 10) > 0 ? css.zIndex : "999999";
      css.position = "fixed";
      css.height = "100%";
      css.width = "100%"; // css.height = Math.max(window.innerHeight,document.documentElement.clientHeight,document.body.clientHeight) +'px'
      // css.width = window.innerWidth +'px'
      // css.top = '0'
      // css.left = '0'
    }

    bindCSS(gwmDiv, css);
    return gwmDiv;
  };

  var DEFAULT_STYLE = Object.create({
    position: "fixed",
    top: 0,
    right: 0,
    bottom: 0,
    left: 0,
    overflow: "hidden",
    zIndex: -10,
    backgroundRepeat: "no-repeat",
    display: "block",
    opacity: "1",
  });
  var WatermarkType;

  (function (WatermarkType) {
    WatermarkType["CANVAS"] = "canvas";
    WatermarkType["SVG"] = "svg";
    WatermarkType["ELEMENT"] = "element";
  })(WatermarkType || (WatermarkType = {}));

  var wayFactory = function wayFactory(mode, wm) {
    switch (mode) {
      case WatermarkType.CANVAS:
        return new CanvasWay(wm);

      case WatermarkType.SVG:
        return new SvgWay(wm);

      default:
        return new ElementWay(wm);
    }
  };

  var getElement = function getElement(container) {
    if (typeof container === "string") {
      var dom = document.querySelector(container);

      if (dom) {
        return dom;
      }

      return document.body;
    }

    return container;
  };

  var GenerateWatermark =
    /** @class */
    (function () {
      function GenerateWatermark() {}

      GenerateWatermark.prototype.creation = function (opts) {
        this.opts = opts;
        this.opts.css = assignStyle(DEFAULT_STYLE, opts.css);
        this.cancel();
        var mode = opts.mode,
          watch = opts.watch,
          _a = opts.container,
          container = _a === void 0 ? document.body : _a;
        this.wrap = getElement(container);

        if (this.wrap !== document.body) {
          this.opts.css.position = "absolute";
          bindCSS(
            this.wrap,
            Object.create({
              position: "relative",
            })
          );
        }

        this.gwmDom = creator(this);
        var wm = new Watermark(opts);
        var impl = wayFactory(mode || WatermarkType.SVG, wm);
        var result = impl.render();

        if (mode === WatermarkType.ELEMENT) {
          this.gwmDom.appendChild(result);
        } else {
          this.gwmDom.style.background = 'url("' + result + '")';
        }

        var first = this.wrap.firstChild;

        if (first) {
          this.wrap.insertBefore(this.gwmDom, first);
        } else {
          this.wrap.appendChild(this.gwmDom);
        }

        if (typeof watch === "boolean" && !watch) {
          this.observer = this.observing();
        }

        if (opts.destroy) {
          this.creation = function (f) {
            return f;
          };
        }
      };

      GenerateWatermark.prototype.observing = function () {
        var _this = this;

        return observer(this.gwmDom, this.wrap, function () {
          return _this.creation(_this.opts);
        });
      };

      GenerateWatermark.prototype.cancel = function () {
        if (this.observer) {
          disconnect(this.observer);
        }
      };

      return GenerateWatermark;
    })();

  var index = new GenerateWatermark();

  var disableCtrlCopyMessage = "";
  var disableF12Message = "";
  var disableCtrlSaveMessage = "";
  var disableCtrlUMessage = "";
  /**
   * 禁止 Ctrl + c 按键的事件监听器
   * @param keyboardEvent 键盘事件
   */

  function disableKeydownCtrlCopyEventListener(keyboardEvent) {
    if (keyboardEvent.ctrlKey && keyboardEvent.key === "c") {
      if (disableCtrlCopyMessage !== undefined) {
        alert(disableCtrlCopyMessage);
      }

      keyboardEvent.preventDefault();
    }
  }
  /**
   * 禁止 F12 按键的事件监听器
   * @param keyboardEvent 键盘事件
   */

  function disableKeydownF12EventListener(keyboardEvent) {
    if (keyboardEvent.key === "F12") {
      if (disableF12Message !== undefined) {
        alert(disableF12Message);
      }

      keyboardEvent.preventDefault();
    }
  }

  function disableKeydownCtrlSaveEventListener(keyboardEvent) {
    if (keyboardEvent.ctrlKey && keyboardEvent.key === "s") {
      if (disableCtrlSaveMessage !== undefined) {
        alert(disableCtrlSaveMessage);
      }

      keyboardEvent.preventDefault();
    }
  }

  function disableKeydownViewOriginCodeEventListener(keyboardEvent) {
    if (keyboardEvent.ctrlKey && keyboardEvent.key === "u") {
      if (disableCtrlUMessage !== undefined) {
        alert(disableCtrlUMessage);
      }

      keyboardEvent.preventDefault();
    }
  }

  var dstpSecurityPage = {
    // 添加水印
    //加一个加水印的方法，同时能创建加水印和更新
    //    watermark: gwm,//不能暴露给应用，1.1.3版本watermark不能给应用
    //写参数
    //gwm有如下方法：creation(创建水印）、observing（手动开启观察者，当水印被篡改时，重新渲染水印元素）
    //cancel（取消观察者）
    createWatermarking: function createWatermarking(params) {
      var defaultParams = {
        //默认参数
        font: "simSum",
        fontSize: 20,
        width: 300,
        height: 300,
        x: 0,
        y: 260,
        color: "#000",
        alpha: 0.1,
        angle: -45,
        container: document.body,
      };
      var watermarkingParams = Object.assign(defaultParams, params);
      index.creation(watermarkingParams);
      index.observing();
    },
    // 禁止通过 Ctrl + c 按键形式进行复制
    disableCtrlCopy: function disableCtrlCopy(message) {
      disableCtrlCopyMessage = message;
      window.addEventListener("keydown", disableKeydownCtrlCopyEventListener);
    },
    // 禁止右键
    disableRightClick: function disableRightClick() {
      document.oncontextmenu = function () {
        return false;
      };
    },
    // 禁止F12
    disableF12: function disableF12(message) {
      disableF12Message = message;
      window.addEventListener("keydown", disableKeydownF12EventListener);
    },
    disableSave: function disableSave(message) {
      disableCtrlSaveMessage = message;
      window.addEventListener("keydown", disableKeydownCtrlSaveEventListener);
    },
    disableViewOriginCode: function disableViewOriginCode(message) {
      disableCtrlUMessage = message;
      window.addEventListener(
        "keydown",
        disableKeydownViewOriginCodeEventListener
      );
    },
    // 禁止截屏。通过页面失焦时黑屏实现。

    /** @deprecated */
    disablePrint: function disablePrint() {
      var screenshotCanvas = document.createElement("canvas");

      window.onblur = function (payload) {
        screenshotCanvas.id = "screenshotCanvas";
        screenshotCanvas.style.backgroundColor = "#000";
        screenshotCanvas.style.height =
          Math.max(window.outerHeight, document.body.scrollHeight) + "px";
        screenshotCanvas.style.width =
          Math.max(window.outerWidth, document.body.scrollWidth) + "px";
        screenshotCanvas.style.position = "absolute";
        screenshotCanvas.style.top = "0";
        screenshotCanvas.style.left = "0";
        document.body.appendChild(screenshotCanvas);
      };

      window.onfocus = function () {
        screenshotCanvas.remove();
      };
    },
    // 清除添加的事件监听器
    clear: function clear() {
      window.removeEventListener("keydown", disableKeydownCtrlCEventListener);
      window.removeEventListener("keydown", disableKeydownF12EventListener);
      window.removeEventListener("keydown", disableKeydownSaveEventListener);
      window.removeEventListener(
        "keydown",
        disableKeydownViewOriginCodeEventListener
      ); // 清除防截屏功能

      window.onblur = function () {};

      window.onfocus = function () {};
    },
  };

  return dstpSecurityPage;
});
